| # Copyright 2019 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.front_end import attribute_checker |
| from compiler.front_end import glue |
| from compiler.util import error |
| from compiler.util import ir_data |
| from compiler.util import ir_util |
| from compiler.util import test_util |
| |
| # These are not shared with attribute_checker.py because their values are part |
| # of the contract with back ends. |
| _BYTE_ORDER = "byte_order" |
| _FIXED_SIZE = "fixed_size_in_bits" |
| _IS_SIGNED = "is_signed" |
| _MAX_BITS = "maximum_bits" |
| |
| |
| 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}), |
| stop_before_step="normalize_and_verify", |
| ) |
| assert not errors |
| return ir |
| |
| |
| class NormalizeIrTest(unittest.TestCase): |
| |
| def test_rejects_may_be_used_as_integer(self): |
| enum_ir = _make_ir_from_emb( |
| "enum Foo:\n" " [may_be_used_as_integer: false]\n" " VALUE = 1\n" |
| ) |
| enum_type_ir = enum_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| enum_type_ir.attribute[0].name.source_location, |
| "Unknown attribute 'may_be_used_as_integer' on enum 'Foo'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(enum_ir), |
| ) |
| |
| def test_adds_fixed_size_attribute_to_struct(self): |
| # field2 is intentionally after field3, in order to trigger certain code |
| # paths in attribute_checker.py. |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+2] UInt field1\n" |
| " 4 [+4] UInt field2\n" |
| " 2 [+2] UInt field3\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(struct_ir)) |
| size_attr = ir_util.get_attribute( |
| struct_ir.module[0].type[0].attribute, _FIXED_SIZE |
| ) |
| self.assertEqual(64, ir_util.constant_value(size_attr.expression)) |
| self.assertEqual( |
| struct_ir.module[0].type[0].source_location, size_attr.source_location |
| ) |
| |
| def test_adds_fixed_size_attribute_to_struct_with_virtual_field(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+2] UInt field1\n" |
| " let field2 = field1\n" |
| " 2 [+2] UInt field3\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(struct_ir)) |
| size_attr = ir_util.get_attribute( |
| struct_ir.module[0].type[0].attribute, _FIXED_SIZE |
| ) |
| self.assertEqual(32, ir_util.constant_value(size_attr.expression)) |
| self.assertEqual( |
| struct_ir.module[0].type[0].source_location, size_attr.source_location |
| ) |
| |
| def test_adds_fixed_size_attribute_to_anonymous_bits(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+4] bits:\n" |
| " 0 [+8] UInt field\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(struct_ir)) |
| size_attr = ir_util.get_attribute( |
| struct_ir.module[0].type[0].attribute, _FIXED_SIZE |
| ) |
| self.assertEqual(32, ir_util.constant_value(size_attr.expression)) |
| bits_size_attr = ir_util.get_attribute( |
| struct_ir.module[0].type[0].subtype[0].attribute, _FIXED_SIZE |
| ) |
| self.assertEqual(8, ir_util.constant_value(bits_size_attr.expression)) |
| self.assertEqual( |
| struct_ir.module[0].type[0].source_location, size_attr.source_location |
| ) |
| |
| def test_does_not_add_fixed_size_attribute_to_variable_size_struct(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+4] UInt n\n" |
| " 4 [+n] UInt:8[] payload\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(struct_ir)) |
| self.assertIsNone( |
| ir_util.get_attribute(struct_ir.module[0].type[0].attribute, _FIXED_SIZE) |
| ) |
| |
| def test_accepts_correct_fixed_size_and_size_attributes_on_struct(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " [fixed_size_in_bits: 64]\n" |
| " 0 [+2] UInt field1\n" |
| " 2 [+2] UInt field2\n" |
| " 4 [+4] UInt field3\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(struct_ir)) |
| size_attr = ir_util.get_attribute( |
| struct_ir.module[0].type[0].attribute, _FIXED_SIZE |
| ) |
| self.assertTrue(size_attr) |
| self.assertEqual(64, ir_util.constant_value(size_attr.expression)) |
| |
| def test_accepts_correct_size_attribute_on_struct(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " [fixed_size_in_bits: 64]\n" |
| " 0 [+2] UInt field1\n" |
| " 4 [+4] UInt field3\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(struct_ir)) |
| size_attr = ir_util.get_attribute( |
| struct_ir.module[0].type[0].attribute, _FIXED_SIZE |
| ) |
| self.assertTrue(size_attr.expression) |
| self.assertEqual(64, ir_util.constant_value(size_attr.expression)) |
| |
| def test_rejects_incorrect_fixed_size_attribute_on_variable_size_struct(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " [fixed_size_in_bits: 8]\n" |
| " 0 [+4] UInt n\n" |
| " 4 [+n] UInt:8[] payload\n" |
| ) |
| struct_type_ir = struct_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| struct_type_ir.attribute[0].value.source_location, |
| "Struct is marked as fixed size, but contains variable-location " |
| "fields.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(struct_ir), |
| ) |
| |
| def test_rejects_size_attribute_with_wrong_large_value_on_struct(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " [fixed_size_in_bits: 80]\n" |
| " 0 [+2] UInt field1\n" |
| " 2 [+2] UInt field2\n" |
| " 4 [+4] UInt field3\n" |
| ) |
| struct_type_ir = struct_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| struct_type_ir.attribute[0].value.source_location, |
| "Struct is 64 bits, but is marked as 80 bits.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(struct_ir), |
| ) |
| |
| def test_rejects_size_attribute_with_wrong_small_value_on_struct(self): |
| struct_ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " [fixed_size_in_bits: 40]\n" |
| " 0 [+2] UInt field1\n" |
| " 2 [+2] UInt field2\n" |
| " 4 [+4] UInt field3\n" |
| ) |
| struct_type_ir = struct_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| struct_type_ir.attribute[0].value.source_location, |
| "Struct is 64 bits, but is marked as 40 bits.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(struct_ir), |
| ) |
| |
| def test_accepts_variable_size_external(self): |
| external_ir = _make_ir_from_emb( |
| "external Foo:\n" " [addressable_unit_size: 1]\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(external_ir)) |
| |
| def test_accepts_fixed_size_external(self): |
| external_ir = _make_ir_from_emb( |
| "external Foo:\n" |
| " [fixed_size_in_bits: 32]\n" |
| " [addressable_unit_size: 1]\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(external_ir)) |
| |
| def test_rejects_external_with_no_addressable_unit_size_attribute(self): |
| external_ir = _make_ir_from_emb("external Foo:\n" " [is_integer: false]\n") |
| external_type_ir = external_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| external_type_ir.source_location, |
| "Expected 'addressable_unit_size' attribute for external type.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(external_ir), |
| ) |
| |
| def test_rejects_is_integer_with_non_constant_value(self): |
| external_ir = _make_ir_from_emb( |
| "external Foo:\n" |
| " [is_integer: $static_size_in_bits == 1]\n" |
| " [addressable_unit_size: 1]\n" |
| ) |
| external_type_ir = external_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| external_type_ir.attribute[0].value.source_location, |
| "Attribute 'is_integer' must have a constant boolean value.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(external_ir), |
| ) |
| |
| def test_rejects_addressable_unit_size_with_non_constant_value(self): |
| external_ir = _make_ir_from_emb( |
| "external Foo:\n" |
| " [is_integer: true]\n" |
| " [addressable_unit_size: $static_size_in_bits]\n" |
| ) |
| external_type_ir = external_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| external_type_ir.attribute[1].value.source_location, |
| "Attribute 'addressable_unit_size' must have a constant value.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(external_ir), |
| ) |
| |
| def test_rejects_external_with_wrong_addressable_unit_size_attribute(self): |
| external_ir = _make_ir_from_emb( |
| "external Foo:\n" " [addressable_unit_size: 4]\n" |
| ) |
| external_type_ir = external_ir.module[0].type[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| external_type_ir.source_location, |
| "Only values '1' (bit) and '8' (byte) are allowed for the " |
| "'addressable_unit_size' attribute", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(external_ir), |
| ) |
| |
| def test_rejects_duplicate_attribute(self): |
| ir = _make_ir_from_emb( |
| "external Foo:\n" " [is_integer: true]\n" " [is_integer: true]\n" |
| ) |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| ir.module[0].type[0].attribute[1].source_location, |
| "Duplicate attribute 'is_integer'.", |
| ), |
| error.note( |
| "m.emb", |
| ir.module[0].type[0].attribute[0].source_location, |
| "Original attribute", |
| ), |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_duplicate_default_attribute(self): |
| ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| '[$default byte_order: "LittleEndian"]\n' |
| ) |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| ir.module[0].attribute[1].source_location, |
| "Duplicate attribute 'byte_order'.", |
| ), |
| error.note( |
| "m.emb", |
| ir.module[0].attribute[0].source_location, |
| "Original attribute", |
| ), |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_unknown_attribute(self): |
| ir = _make_ir_from_emb("[gibberish: true]\n") |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.name.source_location, |
| "Unknown attribute 'gibberish' on module 'm.emb'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_non_constant_attribute(self): |
| ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " [fixed_size_in_bits: field1]\n" |
| " 0 [+2] UInt field1\n" |
| ) |
| attr = ir.module[0].type[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Attribute 'fixed_size_in_bits' must have a constant value.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_attribute_missing_required_back_end_specifier(self): |
| ir = _make_ir_from_emb('[namespace: "abc"]\n') |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.name.source_location, |
| "Unknown attribute 'namespace' on module 'm.emb'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_accepts_attribute_with_default_known_back_end_specifier(self): |
| ir = _make_ir_from_emb('[(cpp) namespace: "abc"]\n') |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| |
| def test_rejects_attribute_with_specified_back_end_specifier(self): |
| ir = _make_ir_from_emb( |
| '[(c) namespace: "abc"]\n' '[expected_back_ends: "c, cpp"]\n' |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| |
| def test_rejects_cpp_backend_attribute_when_not_in_expected_back_ends(self): |
| ir = _make_ir_from_emb( |
| '[(cpp) namespace: "abc"]\n' '[expected_back_ends: "c"]\n' |
| ) |
| attr = ir.module[0].attribute[0] |
| self.maxDiff = 200000 |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.back_end.source_location, |
| "Back end specifier 'cpp' does not match any expected back end " |
| "specifier for this file: 'c'. Add or update the " |
| "'[expected_back_ends: \"c, cpp\"]' attribute at the file level if " |
| "this back end specifier is intentional.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_expected_back_ends_with_bad_back_end(self): |
| ir = _make_ir_from_emb('[expected_back_ends: "c++"]\n') |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Attribute 'expected_back_ends' must be a comma-delimited list of " |
| 'back end specifiers (like "cpp, proto")), not "c++".', |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_expected_back_ends_with_no_comma(self): |
| ir = _make_ir_from_emb('[expected_back_ends: "cpp z"]\n') |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Attribute 'expected_back_ends' must be a comma-delimited list of " |
| 'back end specifiers (like "cpp, proto")), not "cpp z".', |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_expected_back_ends_with_extra_commas(self): |
| ir = _make_ir_from_emb('[expected_back_ends: "cpp,,z"]\n') |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Attribute 'expected_back_ends' must be a comma-delimited list of " |
| 'back end specifiers (like "cpp, proto")), not "cpp,,z".', |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_accepts_empty_expected_back_ends(self): |
| ir = _make_ir_from_emb('[expected_back_ends: ""]\n') |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| |
| def test_adds_byte_order_attributes_from_default(self): |
| ir = _make_ir_from_emb( |
| '[$default byte_order: "BigEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+2] UInt bar\n" |
| " 2 [+2] UInt baz\n" |
| ' [byte_order: "LittleEndian"]\n' |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| byte_order_attr = ir_util.get_attribute( |
| ir.module[0].type[0].structure.field[0].attribute, _BYTE_ORDER |
| ) |
| self.assertTrue(byte_order_attr.HasField("string_constant")) |
| self.assertEqual("BigEndian", byte_order_attr.string_constant.text) |
| byte_order_attr = ir_util.get_attribute( |
| ir.module[0].type[0].structure.field[1].attribute, _BYTE_ORDER |
| ) |
| self.assertTrue(byte_order_attr.HasField("string_constant")) |
| self.assertEqual("LittleEndian", byte_order_attr.string_constant.text) |
| |
| def test_adds_null_byte_order_attributes(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" |
| " 0 [+1] UInt bar\n" |
| " 1 [+1] UInt baz\n" |
| ' [byte_order: "LittleEndian"]\n' |
| " 2 [+2] UInt:8[] baseball\n" |
| " 4 [+2] UInt:8[] bat\n" |
| ' [byte_order: "LittleEndian"]\n' |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| structure = ir.module[0].type[0].structure |
| byte_order_attr = ir_util.get_attribute( |
| structure.field[0].attribute, _BYTE_ORDER |
| ) |
| self.assertTrue(byte_order_attr.HasField("string_constant")) |
| self.assertEqual("Null", byte_order_attr.string_constant.text) |
| self.assertEqual( |
| structure.field[0].source_location, byte_order_attr.source_location |
| ) |
| byte_order_attr = ir_util.get_attribute( |
| structure.field[1].attribute, _BYTE_ORDER |
| ) |
| self.assertTrue(byte_order_attr.HasField("string_constant")) |
| self.assertEqual("LittleEndian", byte_order_attr.string_constant.text) |
| byte_order_attr = ir_util.get_attribute( |
| structure.field[2].attribute, _BYTE_ORDER |
| ) |
| self.assertTrue(byte_order_attr.HasField("string_constant")) |
| self.assertEqual("Null", byte_order_attr.string_constant.text) |
| self.assertEqual( |
| structure.field[2].source_location, byte_order_attr.source_location |
| ) |
| byte_order_attr = ir_util.get_attribute( |
| structure.field[3].attribute, _BYTE_ORDER |
| ) |
| self.assertTrue(byte_order_attr.HasField("string_constant")) |
| self.assertEqual("LittleEndian", byte_order_attr.string_constant.text) |
| |
| def test_disallows_default_byte_order_on_field(self): |
| ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+2] UInt bar\n" |
| ' [$default byte_order: "LittleEndian"]\n' |
| ) |
| default_byte_order = ir.module[0].type[0].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| default_byte_order.name.source_location, |
| "Attribute 'byte_order' may not be defaulted on struct field 'bar'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_default_byte_order_on_bits(self): |
| ir = _make_ir_from_emb( |
| "bits Foo:\n" |
| ' [$default byte_order: "LittleEndian"]\n' |
| " 0 [+2] UInt bar\n" |
| ) |
| default_byte_order = ir.module[0].type[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| default_byte_order.name.source_location, |
| "Attribute 'byte_order' may not be defaulted on bits 'Foo'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_default_byte_order_on_enum(self): |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" ' [$default byte_order: "LittleEndian"]\n' " BAR = 1\n" |
| ) |
| default_byte_order = ir.module[0].type[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| default_byte_order.name.source_location, |
| "Attribute 'byte_order' may not be defaulted on enum 'Foo'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_adds_byte_order_from_scoped_default(self): |
| ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| ' [$default byte_order: "BigEndian"]\n' |
| " 0 [+2] UInt bar\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| byte_order_attr = ir_util.get_attribute( |
| ir.module[0].type[0].structure.field[0].attribute, _BYTE_ORDER |
| ) |
| self.assertTrue(byte_order_attr.HasField("string_constant")) |
| self.assertEqual("BigEndian", byte_order_attr.string_constant.text) |
| |
| def test_disallows_unknown_byte_order(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+2] UInt bar\n" ' [byte_order: "NoEndian"]\n' |
| ) |
| byte_order = ir.module[0].type[0].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| byte_order.value.source_location, |
| "Attribute 'byte_order' must be 'BigEndian' or 'LittleEndian' or " |
| "'Null'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_unknown_default_byte_order(self): |
| ir = _make_ir_from_emb('[$default byte_order: "NoEndian"]\n') |
| default_byte_order = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| default_byte_order.value.source_location, |
| "Attribute 'byte_order' must be 'BigEndian' or 'LittleEndian' or " |
| "'Null'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_byte_order_on_non_byte_order_dependent_fields(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" |
| ' [$default byte_order: "LittleEndian"]\n' |
| " 0 [+2] UInt uint\n" |
| "struct Bar:\n" |
| " 0 [+2] Foo foo\n" |
| ' [byte_order: "LittleEndian"]\n' |
| ) |
| byte_order = ir.module[0].type[1].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| byte_order.value.source_location, |
| "Attribute 'byte_order' not allowed on field which is not byte " |
| "order dependent.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_byte_order_on_virtual_field(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " let x = 10\n" ' [byte_order: "LittleEndian"]\n' |
| ) |
| byte_order = ir.module[0].type[0].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| byte_order.name.source_location, |
| "Unknown attribute 'byte_order' on virtual struct field 'x'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_null_byte_order_on_multibyte_fields(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+2] UInt uint\n" ' [byte_order: "Null"]\n' |
| ) |
| byte_order = ir.module[0].type[0].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| byte_order.value.source_location, |
| "Attribute 'byte_order' may only be 'Null' for one-byte fields.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_null_byte_order_on_multibyte_array_elements(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+4] UInt:16[] uint\n" ' [byte_order: "Null"]\n' |
| ) |
| byte_order = ir.module[0].type[0].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| byte_order.value.source_location, |
| "Attribute 'byte_order' may only be 'Null' for one-byte fields.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_requires_byte_order_on_byte_order_dependent_fields(self): |
| ir = _make_ir_from_emb("struct Foo:\n" " 0 [+2] UInt uint\n") |
| field = ir.module[0].type[0].structure.field[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| field.source_location, |
| "Attribute 'byte_order' required on field which is byte order " |
| "dependent.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_unknown_text_output_attribute(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+2] UInt bar\n" ' [text_output: "None"]\n' |
| ) |
| byte_order = ir.module[0].type[0].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| byte_order.value.source_location, |
| "Attribute 'text_output' must be 'Emit' or 'Skip'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_disallows_non_string_text_output_attribute(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+2] UInt bar\n" " [text_output: 0]\n" |
| ) |
| byte_order = ir.module[0].type[0].structure.field[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| byte_order.value.source_location, |
| "Attribute 'text_output' must be 'Emit' or 'Skip'.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_allows_skip_text_output_attribute_on_physical_field(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+1] UInt bar\n" ' [text_output: "Skip"]\n' |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| |
| def test_allows_skip_text_output_attribute_on_virtual_field(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " let x = 10\n" ' [text_output: "Skip"]\n' |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| |
| def test_allows_emit_text_output_attribute_on_physical_field(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+1] UInt bar\n" ' [text_output: "Emit"]\n' |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| |
| def test_adds_bit_addressable_unit_to_external(self): |
| external_ir = _make_ir_from_emb( |
| "external Foo:\n" " [addressable_unit_size: 1]\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(external_ir)) |
| self.assertEqual( |
| ir_data.AddressableUnit.BIT, external_ir.module[0].type[0].addressable_unit |
| ) |
| |
| def test_adds_byte_addressable_unit_to_external(self): |
| external_ir = _make_ir_from_emb( |
| "external Foo:\n" " [addressable_unit_size: 8]\n" |
| ) |
| self.assertEqual([], attribute_checker.normalize_and_verify(external_ir)) |
| self.assertEqual( |
| ir_data.AddressableUnit.BYTE, external_ir.module[0].type[0].addressable_unit |
| ) |
| |
| def test_rejects_requires_using_array(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+4] UInt:8[] array\n" " [requires: this]\n" |
| ) |
| field_ir = ir.module[0].type[0].structure.field[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| field_ir.attribute[0].value.source_location, |
| "Attribute 'requires' must have a boolean value.", |
| ) |
| ] |
| ], |
| attribute_checker.normalize_and_verify(ir), |
| ) |
| |
| def test_rejects_requires_on_array(self): |
| ir = _make_ir_from_emb( |
| "struct Foo:\n" " 0 [+4] UInt:8[] array\n" " [requires: false]\n" |
| ) |
| field_ir = ir.module[0].type[0].structure.field[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| field_ir.attribute[0].value.source_location, |
| "Attribute 'requires' is only allowed on integer, " |
| "enumeration, or boolean fields, not arrays.", |
| ), |
| error.note("m.emb", field_ir.type.source_location, "Field type."), |
| ] |
| ], |
| error.filter_errors(attribute_checker.normalize_and_verify(ir)), |
| ) |
| |
| def test_rejects_requires_on_struct(self): |
| ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+4] Bar bar\n" |
| " [requires: false]\n" |
| "struct Bar:\n" |
| " 0 [+4] UInt uint\n" |
| ) |
| field_ir = ir.module[0].type[0].structure.field[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| field_ir.attribute[0].value.source_location, |
| "Attribute 'requires' is only allowed on integer, " |
| "enumeration, or boolean fields.", |
| ) |
| ] |
| ], |
| error.filter_errors(attribute_checker.normalize_and_verify(ir)), |
| ) |
| |
| def test_rejects_requires_on_float(self): |
| ir = _make_ir_from_emb( |
| '[$default byte_order: "LittleEndian"]\n' |
| "struct Foo:\n" |
| " 0 [+4] Float float\n" |
| " [requires: false]\n" |
| ) |
| field_ir = ir.module[0].type[0].structure.field[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| field_ir.attribute[0].value.source_location, |
| "Attribute 'requires' is only allowed on integer, " |
| "enumeration, or boolean fields.", |
| ) |
| ] |
| ], |
| error.filter_errors(attribute_checker.normalize_and_verify(ir)), |
| ) |
| |
| def test_adds_false_is_signed_attribute(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " ZERO = 0\n") |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| enum = ir.module[0].type[0] |
| is_signed_attr = ir_util.get_attribute(enum.attribute, _IS_SIGNED) |
| self.assertTrue(is_signed_attr.expression.HasField("boolean_constant")) |
| self.assertFalse(is_signed_attr.expression.boolean_constant.value) |
| |
| def test_leaves_is_signed_attribute(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " [is_signed: true]\n" " ZERO = 0\n") |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| enum = ir.module[0].type[0] |
| is_signed_attr = ir_util.get_attribute(enum.attribute, _IS_SIGNED) |
| self.assertTrue(is_signed_attr.expression.HasField("boolean_constant")) |
| self.assertTrue(is_signed_attr.expression.boolean_constant.value) |
| |
| def test_adds_true_is_signed_attribute(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " NEGATIVE_ONE = -1\n") |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| enum = ir.module[0].type[0] |
| is_signed_attr = ir_util.get_attribute(enum.attribute, _IS_SIGNED) |
| self.assertTrue(is_signed_attr.expression.HasField("boolean_constant")) |
| self.assertTrue(is_signed_attr.expression.boolean_constant.value) |
| |
| def test_adds_max_bits_attribute(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " ZERO = 0\n") |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| enum = ir.module[0].type[0] |
| max_bits_attr = ir_util.get_attribute(enum.attribute, _MAX_BITS) |
| self.assertTrue(max_bits_attr.expression.HasField("constant")) |
| self.assertEqual("64", max_bits_attr.expression.constant.value) |
| |
| def test_leaves_max_bits_attribute(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " [maximum_bits: 32]\n" " ZERO = 0\n") |
| self.assertEqual([], attribute_checker.normalize_and_verify(ir)) |
| enum = ir.module[0].type[0] |
| max_bits_attr = ir_util.get_attribute(enum.attribute, _MAX_BITS) |
| self.assertTrue(max_bits_attr.expression.HasField("constant")) |
| self.assertEqual("32", max_bits_attr.expression.constant.value) |
| |
| def test_rejects_too_small_max_bits(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " [maximum_bits: 0]\n" " ZERO = 0\n") |
| attribute_ir = ir.module[0].type[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attribute_ir.value.source_location, |
| "'maximum_bits' on an 'enum' must be between 1 and 64.", |
| ) |
| ] |
| ], |
| error.filter_errors(attribute_checker.normalize_and_verify(ir)), |
| ) |
| |
| def test_rejects_too_large_max_bits(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " [maximum_bits: 65]\n" " ZERO = 0\n") |
| attribute_ir = ir.module[0].type[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attribute_ir.value.source_location, |
| "'maximum_bits' on an 'enum' must be between 1 and 64.", |
| ) |
| ] |
| ], |
| error.filter_errors(attribute_checker.normalize_and_verify(ir)), |
| ) |
| |
| def test_rejects_unknown_enum_value_attribute(self): |
| ir = _make_ir_from_emb("enum Foo:\n" " BAR = 0 \n" " [bad_attr: true]\n") |
| attribute_ir = ir.module[0].type[0].enumeration.value[0].attribute[0] |
| self.assertNotEqual([], attribute_checker.normalize_and_verify(ir)) |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attribute_ir.name.source_location, |
| "Unknown attribute 'bad_attr' on enum value 'BAR'.", |
| ) |
| ] |
| ], |
| error.filter_errors(attribute_checker.normalize_and_verify(ir)), |
| ) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
