def test_evaluate_sizes_array_with_named_size():
nodes = process([
model.Constant('NUM', '3'),
model.Enum('E', [
model.EnumMember('E1', '1'),
model.EnumMember('E3', 'NUM')
]),
model.Struct('X', [
model.StructMember('x', 'u32', size = 'NUM'),
model.StructMember('y', 'u32', size = 'E1'),
model.StructMember('z', 'u32', size = 'E3')
]),
model.Struct('Y', [
model.StructMember('x', 'u32', size = 'UNKNOWN'),
model.StructMember('y', 'u32')
])
])
assert list(map(get_size_alignment_padding, get_members_and_node(nodes[2]))) == [
(12, 4, 0),
(4, 4, 0),
(12, 4, 0),
(28, 4)
]
assert list(map(get_size_alignment_padding, get_members_and_node(nodes[3]))) == [
(None, None, None),
(4, 4, None),
(None, None)
]
def test_structs_with_dynamic_arrays_bounded_by_the_same_member_parsing_typedef_sizer(
):
content = """\
typedef i32 num_of_elements_t;
typedef num_of_elements_t sz_t;
struct ExtSized
{
sz_t sz;
u32 one<@sz>;
u16 two<@sz>;
i32 three<@sz>;
};
"""
assert parse(content) == [
model.Typedef('num_of_elements_t', 'i32'),
model.Typedef('sz_t', 'num_of_elements_t',
model.Typedef('num_of_elements_t', 'i32', None)),
model.Struct('ExtSized', [
model.StructMember(
'sz', 'sz_t',
model.Typedef('sz_t', 'num_of_elements_t',
model.Typedef('num_of_elements_t', 'i32',
None))),
model.StructMember('one', 'u32', bound='sz'),
model.StructMember('two', 'u16', bound='sz'),
model.StructMember('three', 'i32', bound='sz')
])
]
def test_duplicated_identifiers_struct():
with pytest.raises(model.ModelError,
match="Duplicated 'field_name' identifier in struct A"):
model.Struct("A", [
model.StructMember('field_name', 'u32'),
model.StructMember('field_name', 'u16'),
])
def test_cross_reference_array_size_from_includes():
nodes = [
model.Include('x', [
model.Include('y', [
model.Constant('NUM_HEX', '0xf'),
model.Constant('NUM_DEC', '3'),
]),
model.Enum('E', [
model.EnumMember('E1', 'NUM_HEX'),
model.EnumMember('E3', 'NUM_DEC'),
]),
]),
model.Struct('X', [
model.StructMember('x', 'u32', size='NUM_DEC'),
model.StructMember('y', 'u32', size='E1'),
model.StructMember('z', 'u32', size='UNKNOWN'),
model.StructMember('a', 'u32', size='E3'),
])
]
constants = model.cross_reference(nodes)
assert nodes[1].members[0].numeric_size == 3
assert nodes[1].members[1].numeric_size == 15
assert nodes[1].members[2].numeric_size is None
assert nodes[1].members[3].numeric_size == 3
assert constants == {
'E1': 15,
'E3': 3,
'NUM_DEC': 3,
'NUM_HEX': 15,
}
def test_swap_struct_with_optional_element():
nodes = [
model.Struct("X", [(model.StructMember("x", "u32", optional=True)),
(model.StructMember("y", "Y", optional=True))])
]
assert generate_swap(nodes) == """\
def test_isar_struct_parsing_ext_sized_array():
xml = """\
<x>
<struct name="StructX">
<member name="a" type="u8"/>
<member name="numOfZzz" type="u16"/>
<member name="prophy_styled_x" type="u16">
<dimension isVariableSize="true" variableSizeFieldName="@a"/>
</member>
<member name="prophy_styled_y" type="u16">
<dimension isVariableSize="true" variableSizeFieldName="@a"/>
</member>
<member name="nativeIsarDefined" type="u32">
<dimension size="THIS_IS_VARIABLE_SIZE_ARRAY"/>
</member>
</struct>
</x>
"""
assert parse(xml) == [
model.Struct("StructX", [
model.StructMember("a", "u8"),
model.StructMember("numOfZzz", "u16"),
model.StructMember("prophy_styled_x", "u16", bound = "a"),
model.StructMember("prophy_styled_y", "u16", bound = "a"),
model.StructMember("nativeIsarDefined", "u32", bound = "numOfNativeIsarDefined")
])
]
def test_multiple_enums():
hpp = """\
typedef enum Enum
{
Enum_One = 1,
Enum_Two = 2,
Enum_Three = 3
} Enum;
struct X
{
Enum a;
Enum b;
Enum c;
};
"""
assert parse(hpp) == [
model.Enum("Enum", [
model.EnumMember("Enum_One", "1"),
model.EnumMember("Enum_Two", "2"),
model.EnumMember("Enum_Three", "3")
]),
model.Struct("X", [
model.StructMember("a", "Enum"),
model.StructMember("b", "Enum"),
model.StructMember("c", "Enum")
])
]
def test_swap_struct_with_dynamic_array_of_fixed_elements():
nodes = [
model.Struct("X", [(model.StructMember("num_of_x", "u32")),
(model.StructMember("x", "u16", bound="num_of_x"))])
]
assert generate_swap(nodes) == """\
def test_cross_reference_array_size_from_includes():
nodes = [
model.Include('x', [
model.Include('y', [
model.Constant('NUM', '3'),
]),
model.Enum('E', [
model.EnumMember('E1', '1'),
model.EnumMember('E3', 'NUM')
]),
]),
model.Struct('X', [
model.StructMember('x', 'u32', size = 'NUM'),
model.StructMember('y', 'u32', size = 'E1'),
model.StructMember('z', 'u32', size = 'UNKNOWN'),
model.StructMember('a', 'u32', size = 'E3')
])
]
model.cross_reference(nodes)
assert nodes[1].members[0].numeric_size == 3
assert nodes[1].members[1].numeric_size == 1
assert nodes[1].members[2].numeric_size == None
assert nodes[1].members[3].numeric_size == 3
def test_swap_struct_with_limited_array_of_fixed_elements():
nodes = [
model.Struct(
"X", [(model.StructMember("num_of_x", "u16")),
(model.StructMember("x", "Y", bound="num_of_x", size=3))])
]
assert generate_swap(nodes) == """\
def test_swap_struct_with_ext_sized_array_of_fixed_elements():
nodes = process([
model.Struct("X", [(model.StructMember("szr", "u32")),
(model.StructMember("x", "u16", bound="szr")),
(model.StructMember("y", "u16", bound="szr"))])
])
assert generate_swap(nodes) == """\
def test_swap_struct_with_optional_element():
nodes = process([
model.Typedef('Y', 'u32'),
model.Struct("X", [(model.StructMember("x", "u32", optional=True)),
(model.StructMember("y", "Y", optional=True))])
])
assert generate_swap(nodes[-1:]) == """\
def test_swap_struct_with_greedy_array():
nodes = [
model.Struct("X", [(model.StructMember("x", "u8")),
(model.StructMember("y", "Y", unlimited=True))]),
model.Struct("Z", [(model.StructMember("z", "X"))])
]
assert generate_swap(nodes) == """\
def test_model_sort_struct_with_two_deps():
nodes = [model.Struct("C", [model.StructMember("a", "B")]),
model.Struct("B", [model.StructMember("a", "A")]),
model.Struct("A", [model.StructMember("a", "X")])]
model.topological_sort(nodes)
assert ["A", "B", "C"] == [node.name for node in nodes]
def test_definitions_struct():
nodes = [
model.Struct("Struct", [(model.StructMember("a", "u8")),
(model.StructMember("b", "i64")),
(model.StructMember("c", "r32")),
(model.StructMember("d", "TTypeX"))])
]
assert generate_definitions(nodes) == """\
def test_swap_struct_with_dynamic_element():
nodes = process([
model.Struct("Dynamic",
[(model.StructMember("num_of_x", "u32")),
(model.StructMember("x", "u16", bound="num_of_x"))]),
model.Struct("X", [(model.StructMember("a", "Dynamic"))])
])
assert generate_swap(nodes) == """\
def test_swap_struct_with_limited_array_of_fixed_elements():
nodes = process([
model.Typedef('Y', 'u32'),
model.Struct(
"X", [(model.StructMember("num_of_x", "u16")),
(model.StructMember("x", "Y", bound="num_of_x", size=3))])
])
assert generate_swap(nodes[-1:]) == """\
def test_swap_struct_with_dynamic_field_and_tail_fixed():
nodes = [
model.Struct("X", [(model.StructMember("num_of_x", "u8")),
(model.StructMember("x", "u8", bound="num_of_x")),
(model.StructMember("y", "u32")),
(model.StructMember("z", "u64"))])
]
assert generate_swap(nodes) == """\
def test_definitions_struct_with_dynamic_array():
nodes = [
model.Struct("Struct", [
model.StructMember("tmpName", "TNumberOfItems"),
model.StructMember("a", "u8", bound="tmpName")
])
]
assert generate_definitions(nodes) == """\
def test_swap_struct_with_many_arrays_passing_numbering_fields():
nodes = [
model.Struct("X", [(model.StructMember("num_of_x", "u32")),
(model.StructMember("num_of_y", "u32")),
(model.StructMember("x", "u32", bound="num_of_x")),
(model.StructMember("y", "u32", bound="num_of_y"))])
]
assert generate_swap(nodes) == """\
def test_definitions_struct():
nodes = process([
model.Typedef('TTypeX', 'u32'),
model.Struct("Struct", [(model.StructMember("a", "u8")),
(model.StructMember("b", "i64")),
(model.StructMember("c", "r32")),
(model.StructMember("d", "TTypeX"))])
])
assert generate_definitions(nodes[-1:]) == """\
def test_definitions_struct_with_dynamic_array():
nodes = process([
model.Typedef('TNumberOfItems', 'u32'),
model.Struct("Struct", [
model.StructMember("tmpName", "TNumberOfItems"),
model.StructMember("a", "u8", bound="tmpName")
])
])
assert generate_definitions(nodes[-1:]) == """\
def test_swap_struct_with_greedy_array():
nodes = process([
model.Typedef('X', 'u32'),
model.Typedef('Y', 'u32'),
model.Struct("X", [(model.StructMember("x", "u8")),
(model.StructMember("y", "Y", unlimited=True))]),
model.Struct("Z", [(model.StructMember("z", "X"))])
])
assert generate_swap(nodes) == """\
def test_swap_struct_with_many_arrays_bounded_by_the_same_member():
nodes = process([
model.Struct(
"X", [(model.StructMember("num_of_elements", "u32")),
(model.StructMember("dummy", "u32")),
(model.StructMember("x", "u32", bound="num_of_elements")),
(model.StructMember("y", "u32", bound="num_of_elements"))])
])
assert generate_swap(nodes) == """\
def test_definitions_struct_with_limited_array():
nodes = [
model.Struct("Struct", [
model.StructMember("a_len", "u8"),
model.StructMember(
"a", "u8", bound="a_len", size="NUM_OF_ARRAY_ELEMS")
])
]
assert generate_definitions(nodes) == """\
def test_model_sort_structs():
nodes = [
model.Struct("C", [
model.StructMember("a", "B"),
model.StructMember("b", "A"),
model.StructMember("c", "D"),
]),
model.Struct("B", [
model.StructMember("a", "X"),
model.StructMember("b", "A"),
model.StructMember("c", "Y"),
]),
model.Struct("A", [
model.StructMember("a", "X"),
model.StructMember("b", "Y"),
model.StructMember("c", "Z"),
]),
]
model.topological_sort(nodes)
assert [node.name for node in nodes] == ["A", "B", "C"]
assert [tuple(node.dependencies()) for node in nodes] == [('X', 'Y', 'Z'),
('X', 'A', 'Y'),
('B', 'A', 'D')]
def test_insert_field():
nodes = [
model.Struct("MyStruct", [
model.StructMember("field1", "u32"),
model.StructMember("field2", "u32"),
model.StructMember("field3", "u32")
])
]
patches = {
'MyStruct': [
patch.Action('insert', ['1', 'additional1', 'u8']),
patch.Action('insert', ['-1', 'additional2', 'u16']),
patch.Action('insert', ['128', 'additional3', 'u64'])
]
}
patch.patch(nodes, patches)
assert [
model.Struct('MyStruct', [
model.StructMember('field1', 'u32'),
model.StructMember('additional1', 'u8'),
model.StructMember('field2', 'u32'),
model.StructMember('additional2', 'u16'),
model.StructMember('field3', 'u32'),
model.StructMember('additional3', 'u64')
])
] == nodes
def test_cross_reference_structs():
nodes = [
model.Struct("A", [
model.StructMember("a", "u8")
]),
model.Struct("B", [
model.StructMember("a", "A"),
model.StructMember("b", "u8")
]),
model.Struct("C", [
model.StructMember("a", "A"),
model.StructMember("b", "B"),
model.StructMember("c", "NON_EXISTENT")
]),
model.Struct("D", [
model.StructMember("a", "A"),
model.StructMember("b", "B"),
model.StructMember("c", "C")
])
]
model.cross_reference(nodes)
definition_names = [[x.definition.name if x.definition else None for x in y.members] for y in nodes]
assert definition_names == [
[None],
['A', None],
['A', 'B', None],
['A', 'B', 'C']
]
def test_definitions_struct_many_arrays_mixed():
nodes = [
model.Struct("ManyArraysMixed", [
model.StructMember("num_of_a", "u8"),
model.StructMember("num_of_b", "u8"),
model.StructMember("a", "u8", bound="num_of_a"),
model.StructMember("b", "u8", bound="num_of_b")
])
]
assert generate_definitions(nodes) == """\
def test_swap_struct_with_many_dynamic_fields():
nodes = [
model.Struct("Y",
[(model.StructMember("num_of_x", "u32")),
(model.StructMember("x", "u16", bound="num_of_x"))]),
model.Struct("X", [(model.StructMember("x", "Y")),
(model.StructMember("y", "Y")),
(model.StructMember("z", "Y"))])
]
assert generate_swap(nodes) == """\
