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_struct_rendering_with_byte():
nodes = [model.Struct("Struct", [model.StructMember("a", "byte")])]
ref = """\
class Struct(prophy.with_metaclass(prophy.struct_generator, prophy.struct)):
_descriptor = [
('a', prophy.u8),
]
"""
assert serialize(nodes) == ref
def test_struct_rendering_with_optional():
nodes = [
model.Struct("Struct", [model.StructMember("a", "u32", optional=True)])
]
ref = """\
class Struct(prophy.with_metaclass(prophy.struct_generator, prophy.struct)):
_descriptor = [('a', prophy.optional(prophy.u32))]
"""
assert ref == serialize(nodes)
def test_struct_repr():
struct = model.Struct("MyStruct", [
model.StructMember("a", "u8"),
model.StructMember("b", "u16", bound='xlen'),
model.StructMember("c", "u32", size=5),
model.StructMember("d", "u64", bound='xlen', size=5),
model.StructMember("e", "UU", unlimited=True),
model.StructMember("f", "UUUU", optional=True)
])
assert str(struct) == """\
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_insert_field_no_3_params():
nodes = [model.Struct("MyStruct", [model.StructMember("field1", "u32")])]
patches = {
'MyStruct':
[patch.Action('insert', ['1', 'additional1', 'u8', 'extra'])]
}
with pytest.raises(Exception) as e:
patch.patch(nodes, patches)
assert 'Change field must have 3 params: MyStruct' in str(e.value)
def make_struct(xml_elem, last_member_array_is_dynamic=False):
if len(xml_elem):
members = []
for member in xml_elem:
for sub_ in make_struct_members(member,
last_member_array_is_dynamic):
members.append(sub_)
return model.Struct(xml_elem.get("name"),
members,
docstring=get_docstr(xml_elem))
def test_make_field_greedy_array():
nodes = [
model.Struct("MyStruct", [
model.StructMember("field1", "u32"),
model.StructMember("field2", "u32"),
model.StructMember("field3", "u32")
])
]
patches = {'MyStruct': [patch.Action('greedy', ['field3'])]}
patch.patch(nodes, patches)
assert [
model.Struct('MyStruct', [
model.StructMember('field1', 'u32'),
model.StructMember('field2', 'u32'),
model.StructMember('field3', 'u32', greedy=True)
])
] == nodes
def test_cross_reference_expression_as_array_size():
nodes = [
model.Struct('X', [
model.StructMember('x', 'u32', size = '2 * 3'),
])
]
model.cross_reference(nodes)
assert nodes[0].members[0].numeric_size == 6
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_partition_many_dynamic_structs():
nodes = [
model.Struct("Dynamic", [
model.StructMember("num_of_a", "u8"),
model.StructMember("a", "u8", bound = "num_of_a")
]),
model.Struct("X", [
model.StructMember("a", "Dynamic"),
model.StructMember("b", "Dynamic"),
model.StructMember("c", "Dynamic")
])
]
model.cross_reference(nodes)
model.evaluate_kinds(nodes)
main, parts = model.partition(nodes[1].members)
assert [x.name for x in main] == ["a"]
assert [[x.name for x in part] for part in parts] == [["b"], ["c"]]
def test_make_field_static_array():
nodes = [
model.Struct("MyStruct", [
model.StructMember("field1", "u32"),
model.StructMember("field2", "u32"),
model.StructMember("field3", "u32")
])
]
patches = {'MyStruct': [patch.Action('static', ['field3', '3'])]}
patch.patch(nodes, patches)
assert [
model.Struct('MyStruct', [
model.StructMember('field1', 'u32'),
model.StructMember('field2', 'u32'),
model.StructMember('field3', 'u32', size='3')
])
] == nodes
def test_make_field_limited_array():
nodes = [
model.Struct("MyStruct", [
model.StructMember("field1", "u32"),
model.StructMember("field2", "u32"),
model.StructMember("field3", "u32", size='20')
])
]
patches = {'MyStruct': [patch.Action('limited', ['field3', 'field2'])]}
patch.patch(nodes, patches)
assert [
model.Struct('MyStruct', [
model.StructMember('field1', 'u32'),
model.StructMember('field2', 'u32'),
model.StructMember('field3', 'u32', bound='field2', size='20')
])
] == 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_change_field_type():
nodes = [
model.Struct("MyStruct", [
model.StructMember("field1", "u32"),
model.StructMember("field2", "u32"),
model.StructMember("field3", "u32")
])
]
patches = {'MyStruct': [patch.Action('type', ['field2', 'TheRealType'])]}
patch.patch(nodes, patches)
assert [
model.Struct('MyStruct', [
model.StructMember('field1', 'u32'),
model.StructMember('field2', 'TheRealType'),
model.StructMember('field3', 'u32')
])
] == nodes
def test_cross_reference_typedef():
nodes = [
model.Struct("A", [
model.StructMember("a", "u8")
]),
model.Typedef("B", "A"),
model.Struct("C", [
model.StructMember("a", "A"),
model.StructMember("b", "B")
]),
model.Typedef("D", "B")
]
model.cross_reference(nodes)
assert nodes[1].definition.name == "A"
assert nodes[2].members[1].definition.definition.name == "A"
assert nodes[3].definition.name == "B"
assert nodes[3].definition.definition.name == "A"
def test_definitions_struct_padding():
nodes = process([
model.Struct("B", [
model.StructMember("num_of_a", "u16"),
model.StructMember("a", "u8", bound="num_of_a")
]),
model.Struct("C", [model.StructMember("a", "u16")]),
model.Struct("X", [
model.StructMember("a", "u8"),
model.StructMember("b", "B"),
model.StructMember("c", "C"),
model.StructMember("d", "u32"),
model.StructMember("num_of_e", "u32"),
model.StructMember("e", "u64", bound="num_of_e"),
model.StructMember("f", "u8")
])
])
assert generate_definitions(nodes[-1:]) == """\
def test_insert_field_index_not_an_int():
nodes = [model.Struct("MyStruct", [model.StructMember("field1", "u32")])]
patches = {
'MyStruct':
[patch.Action('insert', ['not_a_number', 'additional1', 'u8'])]
}
with pytest.raises(Exception) as e:
patch.patch(nodes, patches)
assert 'Index is not a number: MyStruct' in str(e.value)
def test_struct_with_incomplete_array(extension):
hpp = """\
struct X
{
char b[];
};
"""
assert parse(hpp, extension) == [
model.Struct('X', [model.StructMember('b', 'i8')])
]
def test_swap_struct_with_many_arrays_passing_numbering_fields_heavily():
nodes = [
model.Struct("X", [(model.StructMember("num_of_a", "u32")),
(model.StructMember("num_of_b", "u32")),
(model.StructMember("b", "u16", bound="num_of_b")),
(model.StructMember("num_of_c", "u32")),
(model.StructMember("c", "u16", bound="num_of_c")),
(model.StructMember("a", "u16", bound="num_of_a"))])
]
assert generate_swap(nodes) == """\
def test_swap_struct_with_many_arrays():
nodes = [
model.Struct("X", [(model.StructMember("num_of_x", "u32")),
(model.StructMember("x", "u32", bound="num_of_x")),
(model.StructMember("num_of_y", "u32")),
(model.StructMember("y", "u32", bound="num_of_y")),
(model.StructMember("num_of_z", "u32")),
(model.StructMember("z", "u32", bound="num_of_z"))])
]
assert generate_swap(nodes) == """\
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_rename_field():
nodes = [
model.Struct("MyStruct", [
model.StructMember("field1", "u32"),
model.StructMember("field2", "u32"),
model.StructMember("field3", "u32")
])
]
patches = {'MyStruct': [patch.Action('rename', ['field2', 'field69'])]}
patch.patch(nodes, patches)
assert [
model.Struct('MyStruct', [
model.StructMember('field1', 'u32'),
model.StructMember('field69', 'u32'),
model.StructMember('field3', 'u32')
])
] == nodes
def test_nested_typedefs():
hpp = """\
typedef int my_int;
typedef my_int i_like_typedefs;
typedef i_like_typedefs i_really_do;
struct X
{
i_really_do a;
};
"""
assert parse(hpp) == [model.Struct("X", [model.StructMember("a", "i32")])]
def test_omit_bitfields():
hpp = """\
typedef struct X
{
unsigned a: 1;
unsigned b: 1;
unsigned c: 1;
unsigned : 5;
};
"""
assert parse(hpp) == [model.Struct('X', [])]
def test_array():
hpp = """\
#include <stdint.h>
struct X
{
uint32_t a[4];
};
"""
assert parse(hpp) == [
model.Struct("X", [model.StructMember("a", "u32", size=4)])
]
def test_definitions_struct_with_ext_sized_array():
nodes = process([
model.Struct("Struct", [
model.StructMember("count", "u8"),
model.StructMember("a", "u8", bound="count"),
model.StructMember("b", "u8", bound="count"),
model.StructMember("c", "u8", bound="count")
])
])
assert generate_definitions(nodes) == """\
def test_definitions_struct_many_arrays_bounded_by_the_same_member():
nodes = process([
model.Struct("ManyArraysBoundedByTheSame", [
model.StructMember("num_of_elements", "u8"),
model.StructMember("dummy", "u8"),
model.StructMember("a", "u8", bound="num_of_elements"),
model.StructMember("b", "u8", bound="num_of_elements")
])
])
assert generate_definitions(nodes) == """\
def test_evaluate_sizes_empty():
nodes = process([
model.Struct('X', []),
model.Union('X', []),
])
assert list(map(get_size_alignment_padding, get_members_and_node(nodes[0]))) == [
(0, 1)
]
assert list(map(get_size_alignment_padding, get_members_and_node(nodes[1]))) == [
(4, 4)
]
def test_definitions_struct_with_limited_array():
nodes = process([
model.Constant('NUM_OF_ARRAY_ELEMS', '1'),
model.Struct("Struct", [
model.StructMember("a_len", "u8"),
model.StructMember(
"a", "u8", bound="a_len", size="NUM_OF_ARRAY_ELEMS")
])
])
assert generate_definitions(nodes[-1:]) == """\
