blob: 4e7d8c7a7f3f0d07e3145842b800ecfe64e8c055 [file] [log] [blame]
# 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()