def test_union(self):
t = union_type(
"foo",
4,
(
(int_type("int", 4, True), "i"),
(array_type(4, int_type("unsigned char", 1, False)), "a"),
),
)
self.assertPrettyPrint(
t,
"""\
union foo {
int i;
unsigned char a[4];
}""",
)
t = union_type(
"foo",
4,
(
(int_type("int", 4, True), "i"),
(array_type(4, int_type("unsigned char", 1, False)), "a"),
),
Qualifiers.CONST,
)
self.assertPrettyPrint(
t,
"""\
const union foo {
int i;
unsigned char a[4];
}""",
)
def test_enum(self):
t = enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertPrettyPrint(
t,
"""\
enum color {
RED = 0,
GREEN = 1,
BLUE = 2,
}""",
)
t = enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
Qualifiers.CONST,
)
self.assertPrettyPrint(
t,
"""\
const enum color {
RED = 0,
GREEN = 1,
BLUE = 2,
}""",
)
t = enum_type(
None,
int_type("int", 4, True),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", -1),
TypeEnumerator("BLUE", -2),
),
)
self.assertPrettyPrint(
t,
"""\
enum {
RED = 0,
GREEN = -1,
BLUE = -2,
}""",
)
def test_pointer_to_function_returning_pointer_to_const(self):
i = int_type('int', 4, True)
self.assertTypeName(
pointer_type(
8,
function_type(
pointer_type(8, int_type('int', 4, True,
Qualifiers.CONST)), ((i, ), ),
False)), 'const int *(*)(int)', True)
def test_pointer_to_array(self):
prog = mock_program()
self.assertEqual(
prog.type('int (*)[2]'),
pointer_type(8, array_type(2, int_type('int', 4, True))))
self.assertEqual(
prog.type('int (*)[2][3]'),
pointer_type(
8, array_type(2, array_type(3, int_type('int', 4, True)))))
def test_callable(self):
p = TypeParameter(void_type)
self.assertEqual(p.type, void_type())
p = TypeParameter(lambda: int_type("int", 4, True))
self.assertEqual(p.type, int_type("int", 4, True))
p = TypeParameter(lambda: None)
self.assertRaises(TypeError, getattr, p, "type")
def test_callable(self):
m = TypeMember(void_type)
self.assertEqual(m.type, void_type())
m = TypeMember(lambda: int_type("int", 4, True))
self.assertEqual(m.type, int_type("int", 4, True))
m = TypeMember(lambda: None)
self.assertRaises(TypeError, getattr, m, "type")
def test_primitive_type(self):
prog = mock_program(types=[
int_type('long', 4, True),
int_type('unsigned long', 4, True),
])
self.assertEqual(prog.type('long'), int_type('long', 4, True))
# unsigned long with signed=True isn't valid, so it should be ignored.
self.assertEqual(prog.type('unsigned long'),
int_type('unsigned long', 8, False))
def test_variable(self):
mock_obj = MockObject("counter", int_type("int", 4, True), address=0xFFFF0000)
prog = mock_program(objects=[mock_obj])
self.assertEqual(
prog["counter"], Object(prog, int_type("int", 4, True), address=0xFFFF0000)
)
self.assertEqual(
prog.object("counter", FindObjectFlags.VARIABLE), prog["counter"]
)
self.assertTrue("counter" in prog)
def test_constant(self):
mock_obj = MockObject('PAGE_SIZE',
int_type('int', 4, True),
value=4096)
prog = mock_program(objects=[mock_obj])
self.assertEqual(prog['PAGE_SIZE'],
Object(prog, int_type('int', 4, True), value=4096))
self.assertEqual(prog.object('PAGE_SIZE', FindObjectFlags.CONSTANT),
prog['PAGE_SIZE'])
self.assertTrue('PAGE_SIZE' in prog)
def test_pointer_to_array_of_pointers(self):
prog = mock_program()
self.assertEqual(
prog.type('int *(*)[2]'),
pointer_type(
8, array_type(2, pointer_type(8, int_type('int', 4, True)))))
self.assertEqual(
prog.type('int *((*)[2])'),
pointer_type(
8, array_type(2, pointer_type(8, int_type('int', 4, True)))))
def test_function(self):
t = function_type(void_type(), ((int_type('int', 4, True), 'n'), ))
self.assertEqual(t.kind, TypeKind.FUNCTION)
self.assertIsNone(t.primitive)
self.assertEqual(t.type, void_type())
self.assertEqual(t.parameters, ((int_type('int', 4, True), 'n'), ))
self.assertFalse(t.is_variadic)
self.assertTrue(t.is_complete())
self.assertEqual(
t, function_type(void_type(), ((int_type('int', 4, True), 'n'), )))
# Different return type.
self.assertNotEqual(
t,
function_type(int_type('int', 4, True),
((int_type('int', 4, True), 'n'), )))
# Different parameter name.
self.assertNotEqual(
t, function_type(void_type(), ((int_type('int', 4, True), 'x'), )))
# Unnamed parameter.
self.assertNotEqual(
t, function_type(void_type(), ((int_type('int', 4, True), ), )))
# Different number of parameters.
self.assertNotEqual(
t,
function_type(void_type(), ((int_type('int', 4, True), 'n'),
(pointer_type(8, void_type()), 'p'))))
# One is variadic.
self.assertNotEqual(
t,
function_type(void_type(), ((int_type('int', 4, True), 'n'), ),
True))
self.assertEqual(
repr(t),
"function_type(type=void_type(), parameters=((int_type(name='int', size=4, is_signed=True), 'n'),), is_variadic=False)"
)
self.assertRaises(TypeError, sizeof, t)
self.assertFalse(function_type(void_type(), (), False).is_variadic)
self.assertTrue(function_type(void_type(), (), True).is_variadic)
self.assertRaisesRegex(TypeError, 'must be Type', function_type, None,
())
self.assertRaisesRegex(TypeError, 'must be sequence', function_type,
void_type(), None)
self.assertRaisesRegex(TypeError, 'must be.*sequence', function_type,
void_type(), (4, ))
self.assertRaisesRegex(ValueError, 'must be.*sequence', function_type,
void_type, ((), ))
self.assertRaisesRegex(TypeError,
'must be string or None', function_type,
void_type(), ((int_type('int', 4, True), 4), ))
self.assertRaisesRegex(TypeError, 'must be Type', function_type,
void_type(), ((None, 'n'), ))
def test_bit_field(self):
point = struct_type('point', 4, (
(int_type('int', 4, True), 'x', 0, 4),
(int_type('int', 4, True), 'y', 4, 8),
))
self.assertPrettyPrint(
point, """\
struct point {
int x : 4;
int y : 8;
}""")
def test_variable(self):
mock_obj = MockObject('counter',
int_type('int', 4, True),
address=0xffff0000)
prog = mock_program(objects=[mock_obj])
self.assertEqual(
prog['counter'],
Object(prog, int_type('int', 4, True), address=0xffff0000))
self.assertEqual(prog.object('counter', FindObjectFlags.VARIABLE),
prog['counter'])
self.assertTrue('counter' in prog)
def test_language(self):
self.assertEqual(void_type(language=None).language, DEFAULT_LANGUAGE)
self.assertEqual(void_type(language=Language.C).language, Language.C)
self.assertEqual(
int_type("int", 4, True, language=Language.CPP).language,
Language.CPP)
self.assertNotEqual(
int_type("int", 4, True, language=Language.C),
int_type("int", 4, True, language=Language.CPP),
)
def test_pointer_to_function_returning_pointer_to_const(self):
i = int_type("int", 4, True)
self.assertTypeName(
pointer_type(
8,
function_type(
pointer_type(8, int_type("int", 4, True, Qualifiers.CONST)),
(TypeParameter(i),),
False,
),
),
"const int *(*)(int)",
True,
)
def test_pointer_to_array_of_pointers(self):
self.assertTypeName(
pointer_type(
8, array_type(2, pointer_type(8, int_type("int", 4, True)))),
"int *(*)[2]",
True,
)
def test_array_of_pointers_to_array(self):
prog = mock_program()
self.assertEqual(
prog.type("int (*[2])[3]"),
array_type(
2, pointer_type(8, array_type(3, int_type("int", 4, True)))),
)
def test_array_of_pointers_to_functions(self):
i = int_type("int", 4, True)
self.assertTypeName(
array_type(4, pointer_type(8, function_type(i, ((i,),), False))),
"int (*[4])(int)",
True,
)
def test_array_of_const_pointers_to_functions(self):
i = int_type('int', 4, True)
self.assertTypeName(
array_type(
None,
pointer_type(8, function_type(i, ((i, ), ), False),
Qualifiers.CONST)), 'int (* const [])(int)', True)
def test_array_of_pointers(self):
self.assertTypeName(
array_type(
2, array_type(3, pointer_type(8, int_type("int", 4, True)))),
"int *[2][3]",
True,
)
def test_pointer_to_pointer_to_array(self):
self.assertTypeName(
pointer_type(
8, pointer_type(8, array_type(2, int_type("int", 4, True)))),
"int (**)[2]",
True,
)
def test_array_of_pointers_to_array(self):
self.assertTypeName(
array_type(
2, pointer_type(8, array_type(3, int_type("int", 4, True)))),
"int (*[2])[3]",
True,
)
def test_pointer_to_pointer_to_array(self):
prog = mock_program()
self.assertEqual(
prog.type("int (**)[2]"),
pointer_type(
8, pointer_type(8, array_type(2, int_type("int", 4, True)))),
)
def test_pointer_to_variadic_function(self):
i = int_type("int", 4, True)
self.assertTypeName(
pointer_type(8, function_type(i, (TypeParameter(i), ), True)),
"int (*)(int, ...)",
True,
)
def test_pointer_to_function_with_no_parameters(self):
self.assertTypeName(
pointer_type(8, function_type(int_type("int", 4, True), (),
False)),
"int (*)(void)",
True,
)
def test_cmp(self):
self.assertEqual(void_type(), void_type())
self.assertEqual(void_type(Qualifiers.CONST),
void_type(Qualifiers.CONST))
self.assertNotEqual(void_type(), void_type(Qualifiers.CONST))
self.assertNotEqual(void_type(), int_type('int', 4, True))
self.assertNotEqual(void_type(), 1)
self.assertNotEqual(1, void_type())
def test_variable(self):
sym = Symbol(int_type('int', 4, True),
address=0xffff0000,
byteorder='little')
prog = mock_program(symbols=[('counter', sym)])
self.assertEqual(prog._symbol('counter', FindObjectFlags.VARIABLE),
sym)
self.assertEqual(prog._symbol('counter', FindObjectFlags.ANY), sym)
def test_array(self):
i = int_type("int", 4, True)
self.assertTypeName(array_type(None, i), "int []", True)
self.assertTypeName(array_type(2, i), "int [2]", True)
self.assertTypeName(array_type(2, array_type(3, i)), "int [2][3]", True)
self.assertTypeName(
array_type(2, array_type(3, array_type(4, i))), "int [2][3][4]", True
)
def test_array(self):
i = int_type('int', 4, True)
self.assertTypeName(array_type(None, i), 'int []', True)
self.assertTypeName(array_type(2, i), 'int [2]', True)
self.assertTypeName(array_type(2, array_type(3, i)), 'int [2][3]',
True)
self.assertTypeName(array_type(2, array_type(3, array_type(4, i))),
'int [2][3][4]', True)
def test_bit_field(self):
point = struct_type(
"point",
4,
(
(int_type("int", 4, True), "x", 0, 4),
(int_type("int", 4, True), "y", 4, 8),
),
)
self.assertPrettyPrint(
point,
"""\
struct point {
int x : 4;
int y : 8;
}""",
)
