def test_void(self):
t = void_type()
self.assertEqual(t.kind, TypeKind.VOID)
self.assertEqual(t.primitive, PrimitiveType.C_VOID)
self.assertEqual(t, void_type())
self.assertFalse(t.is_complete())
self.assertEqual(repr(t), 'void_type()')
def test_pointer(self):
t = pointer_type(8, int_type('int', 4, True))
self.assertEqual(t.kind, TypeKind.POINTER)
self.assertIsNone(t.primitive)
self.assertEqual(t.size, 8)
self.assertEqual(t.type, int_type('int', 4, True))
self.assertTrue(t.is_complete())
self.assertEqual(t, pointer_type(8, int_type('int', 4, True)))
# Qualified type argument.
self.assertEqual(t, pointer_type(8, int_type('int', 4, True)))
# Different size.
self.assertNotEqual(t, pointer_type(4, int_type('int', 4, True)))
# Different type.
self.assertNotEqual(t, pointer_type(8, void_type()))
self.assertNotEqual(t, pointer_type(8, void_type(Qualifiers.CONST)))
self.assertEqual(
repr(t),
"pointer_type(size=8, type=int_type(name='int', size=4, is_signed=True))"
)
self.assertRaises(TypeError, pointer_type, None,
int_type('int', 4, True))
self.assertRaises(TypeError, pointer_type, 8, 4)
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)
def test_void(self):
t = void_type()
self.assertEqual(t.kind, TypeKind.VOID)
self.assertEqual(t.primitive, PrimitiveType.C_VOID)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t, void_type())
self.assertFalse(t.is_complete())
self.assertEqual(repr(t), "void_type()")
def test_pointer(self):
self.assertTypeName(pointer_type(8, void_type()), "void *", True)
t = pointer_type(8, void_type(Qualifiers.VOLATILE))
self.assertTypeName(t, "volatile void *", True)
t = pointer_type(8, void_type(Qualifiers.VOLATILE), Qualifiers.CONST)
self.assertTypeName(t, "volatile void * const", True)
t = pointer_type(8, t)
self.assertTypeName(t, "volatile void * const *", True)
def test_init(self):
p = TypeParameter(void_type())
self.assertEqual(p.type, void_type())
self.assertIsNone(p.name)
p = TypeParameter(void_type(), "foo")
self.assertEqual(p.type, void_type())
self.assertEqual(p.name, "foo")
self.assertRaises(TypeError, TypeParameter, None)
self.assertRaises(TypeError, TypeParameter, void_type(), 1)
def test_function(self):
mock_obj = MockObject(
"func", function_type(void_type(), (), False), address=0xFFFF0000
)
prog = mock_program(objects=[mock_obj])
self.assertEqual(
prog["func"],
Object(prog, function_type(void_type(), (), False), address=0xFFFF0000),
)
self.assertEqual(prog.object("func", FindObjectFlags.FUNCTION), prog["func"])
self.assertTrue("func" in prog)
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_function(self):
mock_obj = MockObject('func',
function_type(void_type(), (), False),
address=0xffff0000)
prog = mock_program(objects=[mock_obj])
self.assertEqual(
prog['func'],
Object(prog,
function_type(void_type(), (), False),
address=0xffff0000))
self.assertEqual(prog.object('func', FindObjectFlags.FUNCTION),
prog['func'])
self.assertTrue('func' in prog)
def test_qualifiers(self):
self.assertEqual(void_type().qualifiers, Qualifiers(0))
t = void_type(Qualifiers.CONST | Qualifiers.VOLATILE)
self.assertEqual(t.qualifiers, Qualifiers.CONST | Qualifiers.VOLATILE)
self.assertEqual(
repr(t), 'void_type(qualifiers=<Qualifiers.VOLATILE|CONST: 3>)')
self.assertEqual(t.qualified(Qualifiers.ATOMIC),
void_type(Qualifiers.ATOMIC))
self.assertEqual(t.unqualified(), void_type())
self.assertEqual(t.qualified(Qualifiers(0)), t.unqualified())
self.assertRaisesRegex(TypeError, 'expected Qualifiers or None',
void_type, 1.5)
def test_function(self):
sym = Symbol(function_type(void_type(), (), False),
address=0xffff0000,
byteorder='little')
prog = mock_program(symbols=[('func', sym)])
self.assertEqual(prog._symbol('func', FindObjectFlags.FUNCTION), sym)
self.assertEqual(prog._symbol('func', FindObjectFlags.ANY), sym)
def test_complex(self):
t = complex_type('double _Complex', 16, float_type('double', 8))
self.assertEqual(t.kind, TypeKind.COMPLEX)
self.assertIsNone(t.primitive)
self.assertEqual(t.name, 'double _Complex')
self.assertEqual(t.size, 16)
self.assertEqual(t.type, float_type('double', 8))
self.assertTrue(t.is_complete())
self.assertEqual(
t, complex_type('double _Complex', 16, float_type('double', 8)))
self.assertNotEqual(
t, complex_type('float _Complex', 16, float_type('double', 8)))
self.assertNotEqual(
t, complex_type('double _Complex', 32, float_type('double', 8)))
self.assertNotEqual(
t, complex_type('double _Complex', 16, float_type('float', 4)))
self.assertEqual(
repr(t),
"complex_type(name='double _Complex', size=16, type=float_type(name='double', size=8))"
)
self.assertRaises(TypeError, complex_type, None, 16,
float_type('double', 8))
self.assertRaises(TypeError, complex_type, 'double _Complex', 16, None)
self.assertRaisesRegex(ValueError,
'must be floating-point or integer type',
complex_type, 'double _Complex', 16,
void_type())
self.assertRaisesRegex(ValueError, 'must be unqualified', complex_type,
'double _Complex', 16,
float_type('double', 8, Qualifiers.CONST))
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_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_cmp(self):
self.assertEqual(TypeMember(void_type()),
TypeMember(void_type(), None, 0, 0))
self.assertEqual(
TypeMember(bit_offset=9,
bit_field_size=7,
type=void_type,
name="foo"),
TypeMember(void_type(), "foo", 9, 7),
)
self.assertNotEqual(TypeMember(int_type("int", 4, True)),
TypeMember(void_type(), None, 0, 0))
self.assertNotEqual(TypeMember(void_type(), "foo"),
TypeMember(void_type(), None, 0, 0))
self.assertNotEqual(TypeMember(void_type(), bit_offset=8),
TypeMember(void_type(), None, 0, 0))
self.assertNotEqual(
TypeMember(void_type(), bit_field_size=8),
TypeMember(void_type(), None, 0, 0),
)
def test_array(self):
t = array_type(10, int_type("int", 4, True))
self.assertEqual(t.kind, TypeKind.ARRAY)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t.length, 10)
self.assertEqual(t.type, int_type("int", 4, True))
self.assertTrue(t.is_complete())
self.assertEqual(t, array_type(10, int_type("int", 4, True)))
# Qualified type argument.
self.assertEqual(t, array_type(10, int_type("int", 4, True)))
# Different length.
self.assertNotEqual(t, array_type(4, int_type("int", 4, True)))
# Different type.
self.assertNotEqual(t, array_type(10, void_type()))
self.assertNotEqual(t, array_type(10, void_type(Qualifiers.CONST)))
self.assertEqual(
repr(t),
"array_type(length=10, type=int_type(name='int', size=4, is_signed=True))",
)
self.assertEqual(sizeof(t), 40)
t = array_type(0, int_type("int", 4, True))
self.assertEqual(t.kind, TypeKind.ARRAY)
self.assertIsNone(t.primitive)
self.assertEqual(t.length, 0)
self.assertEqual(t.type, int_type("int", 4, True))
self.assertTrue(t.is_complete())
t = array_type(None, int_type("int", 4, True))
self.assertEqual(t.kind, TypeKind.ARRAY)
self.assertIsNone(t.primitive)
self.assertIsNone(t.length)
self.assertEqual(t.type, int_type("int", 4, True))
self.assertFalse(t.is_complete())
self.assertRaises(TypeError, array_type, 10, 4)
def test_cmp(self):
self.assertEqual(TypeParameter(void_type()),
TypeParameter(void_type(), None))
self.assertEqual(TypeParameter(name="foo", type=void_type),
TypeParameter(void_type(), "foo"))
self.assertNotEqual(TypeParameter(int_type("int", 4, True)),
TypeParameter(void_type(), None))
self.assertNotEqual(TypeParameter(void_type(), "foo"),
TypeParameter(void_type(), None))
def test_complex(self):
t = complex_type("double _Complex", 16, float_type("double", 8))
self.assertEqual(t.kind, TypeKind.COMPLEX)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t.name, "double _Complex")
self.assertEqual(t.size, 16)
self.assertEqual(t.type, float_type("double", 8))
self.assertTrue(t.is_complete())
self.assertEqual(
t, complex_type("double _Complex", 16, float_type("double", 8)))
self.assertNotEqual(
t, complex_type("float _Complex", 16, float_type("double", 8)))
self.assertNotEqual(
t, complex_type("double _Complex", 32, float_type("double", 8)))
self.assertNotEqual(
t, complex_type("double _Complex", 16, float_type("float", 4)))
self.assertEqual(
repr(t),
"complex_type(name='double _Complex', size=16, type=float_type(name='double', size=8))",
)
self.assertEqual(sizeof(t), 16)
self.assertRaises(TypeError, complex_type, None, 16,
float_type("double", 8))
self.assertRaises(TypeError, complex_type, "double _Complex", 16, None)
self.assertRaisesRegex(
ValueError,
"must be floating-point or integer type",
complex_type,
"double _Complex",
16,
void_type(),
)
self.assertRaisesRegex(
ValueError,
"must be unqualified",
complex_type,
"double _Complex",
16,
float_type("double", 8, Qualifiers.CONST),
)
def test_typedef(self):
t = typedef_type("INT", int_type("int", 4, True))
self.assertEqual(t.kind, TypeKind.TYPEDEF)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t.name, "INT")
self.assertEqual(t.type, int_type("int", 4, True))
self.assertTrue(t.is_complete())
self.assertEqual(t, typedef_type("INT", int_type("int", 4, True)))
# Qualified type argument.
self.assertEqual(t, typedef_type("INT", int_type("int", 4, True)))
# Different name.
self.assertNotEqual(t, typedef_type("integer",
int_type("int", 4, True)))
# Different type.
self.assertNotEqual(
t, typedef_type("integer", int_type("unsigned int", 4, False)))
self.assertNotEqual(
t, typedef_type("INT", int_type("int", 4, True, Qualifiers.CONST)))
self.assertEqual(
repr(t),
"typedef_type(name='INT', type=int_type(name='int', size=4, is_signed=True))",
)
self.assertEqual(sizeof(t), 4)
t = typedef_type("VOID", void_type())
self.assertFalse(t.is_complete())
self.assertRaises(TypeError, typedef_type, None,
int_type("int", 4, True))
self.assertRaises(TypeError, typedef_type, "INT", 4)
self.assertEqual(
typedef_type("size_t", int_type("unsigned long", 8,
False)).primitive,
PrimitiveType.C_SIZE_T,
)
self.assertEqual(
typedef_type("ptrdiff_t", int_type("long", 8, True)).primitive,
PrimitiveType.C_PTRDIFF_T,
)
def test_typedef(self):
t = typedef_type('INT', int_type('int', 4, True))
self.assertEqual(t.kind, TypeKind.TYPEDEF)
self.assertIsNone(t.primitive)
self.assertEqual(t.name, 'INT')
self.assertEqual(t.type, int_type('int', 4, True))
self.assertTrue(t.is_complete())
self.assertEqual(t, typedef_type('INT', int_type('int', 4, True)))
# Qualified type argument.
self.assertEqual(t, typedef_type('INT', int_type('int', 4, True)))
# Different name.
self.assertNotEqual(t, typedef_type('integer',
int_type('int', 4, True)))
# Different type.
self.assertNotEqual(
t, typedef_type('integer', int_type('unsigned int', 4, False)))
self.assertNotEqual(
t, typedef_type('INT', int_type('int', 4, True, Qualifiers.CONST)))
self.assertEqual(
repr(t),
"typedef_type(name='INT', type=int_type(name='int', size=4, is_signed=True))"
)
self.assertEqual(sizeof(t), 4)
t = typedef_type('VOID', void_type())
self.assertFalse(t.is_complete())
self.assertRaises(TypeError, typedef_type, None,
int_type('int', 4, True))
self.assertRaises(TypeError, typedef_type, 'INT', 4)
self.assertEqual(
typedef_type('size_t', int_type('unsigned long', 8,
False)).primitive,
PrimitiveType.C_SIZE_T)
self.assertEqual(
typedef_type('ptrdiff_t', int_type('long', 8, True)).primitive,
PrimitiveType.C_PTRDIFF_T)
def test_language(self):
self.assertEqual(void_type(language=None).language, DEFAULT_LANGUAGE)
self.assertEqual(void_type(language=Language.C).language, Language.C)
def test_init(self):
m = TypeMember(void_type())
self.assertEqual(m.type, void_type())
self.assertIsNone(m.name)
self.assertEqual(m.bit_offset, 0)
self.assertEqual(m.offset, 0)
self.assertEqual(m.bit_field_size, 0)
m = TypeMember(void_type(), "foo")
self.assertEqual(m.type, void_type())
self.assertEqual(m.name, "foo")
self.assertEqual(m.bit_offset, 0)
self.assertEqual(m.offset, 0)
self.assertEqual(m.bit_field_size, 0)
m = TypeMember(void_type(), "foo", 8)
self.assertEqual(m.type, void_type())
self.assertEqual(m.name, "foo")
self.assertEqual(m.bit_offset, 8)
self.assertEqual(m.offset, 1)
self.assertEqual(m.bit_field_size, 0)
m = TypeMember(void_type(), "foo", 9, 7)
self.assertEqual(m.type, void_type())
self.assertEqual(m.name, "foo")
self.assertEqual(m.bit_offset, 9)
self.assertRaises(ValueError, getattr, m, "offset")
self.assertEqual(m.bit_field_size, 7)
self.assertRaises(TypeError, TypeMember, None)
self.assertRaises(TypeError, TypeMember, void_type(), 1)
self.assertRaises(TypeError, TypeMember, void_type(), "foo", None)
self.assertRaises(TypeError, TypeMember, void_type(), "foo", 0, None)
def test_enum(self):
t = enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t.tag, "color")
self.assertEqual(t.type, int_type("unsigned int", 4, False))
self.assertEqual(
t.enumerators,
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertTrue(t.is_complete())
self.assertEqual(
t,
enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different tag.
self.assertNotEqual(
t,
enum_type(
"COLOR",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# One is anonymous.
self.assertNotEqual(
t,
enum_type(
None,
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different compatible type.
self.assertNotEqual(
t,
enum_type(
"color",
int_type("int", 4, True),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different enumerators.
self.assertNotEqual(
t,
enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("YELLOW", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different number of enumerators.
self.assertNotEqual(
t,
enum_type(
"color",
int_type("unsigned int", 4, False),
(TypeEnumerator("RED", 0), TypeEnumerator("GREEN", 1)),
),
)
# One is incomplete.
self.assertNotEqual(t, enum_type("color"))
self.assertEqual(
repr(t),
"enum_type(tag='color', type=int_type(name='unsigned int', size=4, is_signed=False), enumerators=(TypeEnumerator('RED', 0), TypeEnumerator('GREEN', 1), TypeEnumerator('BLUE', 2)))",
)
self.assertEqual(sizeof(t), 4)
t = enum_type("color", None, None)
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, "color")
self.assertIsNone(t.type)
self.assertIsNone(t.enumerators)
self.assertFalse(t.is_complete())
self.assertEqual(
repr(t), "enum_type(tag='color', type=None, enumerators=None)")
# A type with no enumerators isn't valid in C, but we allow it.
t = enum_type("color", int_type("unsigned int", 4, False), ())
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, "color")
self.assertEqual(t.type, int_type("unsigned int", 4, False))
self.assertEqual(t.enumerators, ())
self.assertTrue(t.is_complete())
self.assertEqual(
repr(t),
"enum_type(tag='color', type=int_type(name='unsigned int', size=4, is_signed=False), enumerators=())",
)
self.assertRaisesRegex(TypeError, "must be Type", enum_type, "color",
4, ())
self.assertRaisesRegex(ValueError, "must be integer type", enum_type,
"color", void_type(), ())
self.assertRaisesRegex(
ValueError,
"must be unqualified",
enum_type,
"color",
int_type("unsigned int", 4, True, Qualifiers.CONST),
(),
)
self.assertRaisesRegex(
ValueError,
"must not have compatible type",
enum_type,
"color",
int_type("unsigned int", 4, False),
None,
)
self.assertRaisesRegex(ValueError, "must have compatible type",
enum_type, "color", None, ())
self.assertRaisesRegex(
TypeError,
"must be sequence or None",
enum_type,
"color",
int_type("unsigned int", 4, False),
4,
)
self.assertRaisesRegex(
TypeError,
"must be TypeEnumerator",
enum_type,
"color",
int_type("unsigned int", 4, False),
(4, ),
)
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.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_enum(self):
t = enum_type('color', int_type('unsigned int', 4, False),
(('RED', 0), ('GREEN', 1), ('BLUE', 2)))
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, 'color')
self.assertEqual(t.type, int_type('unsigned int', 4, False))
self.assertEqual(t.enumerators,
(('RED', 0), ('GREEN', 1), ('BLUE', 2)))
self.assertTrue(t.is_complete())
self.assertEqual(
t,
enum_type('color', int_type('unsigned int', 4, False),
(('RED', 0), ('GREEN', 1), ('BLUE', 2))))
# Different tag.
self.assertNotEqual(
t,
enum_type('COLOR', int_type('unsigned int', 4, False),
(('RED', 0), ('GREEN', 1), ('BLUE', 2))))
# One is anonymous.
self.assertNotEqual(
t,
enum_type(None, int_type('unsigned int', 4, False),
(('RED', 0), ('GREEN', 1), ('BLUE', 2))))
# Different compatible type.
self.assertNotEqual(
t,
enum_type('color', int_type('int', 4, True),
(('RED', 0), ('GREEN', 1), ('BLUE', 2))))
# Different enumerators.
self.assertNotEqual(
t,
enum_type('color', int_type('unsigned int', 4, False),
(('RED', 0), ('YELLOW', 1), ('BLUE', 2))))
# Different number of enumerators.
self.assertNotEqual(
t,
enum_type('color', int_type('unsigned int', 4, False),
(('RED', 0), ('GREEN', 1))))
# One is incomplete.
self.assertNotEqual(t, enum_type('color'))
self.assertEqual(
repr(t),
"enum_type(tag='color', type=int_type(name='unsigned int', size=4, is_signed=False), enumerators=(('RED', 0), ('GREEN', 1), ('BLUE', 2)))"
)
t = enum_type('color', None, None)
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, 'color')
self.assertIsNone(t.type)
self.assertIsNone(t.enumerators)
self.assertFalse(t.is_complete())
self.assertEqual(
repr(t), "enum_type(tag='color', type=None, enumerators=None)")
# A type with no enumerators isn't valid in C, but we allow it.
t = enum_type('color', int_type('unsigned int', 4, False), ())
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, 'color')
self.assertEqual(t.type, int_type('unsigned int', 4, False))
self.assertEqual(t.enumerators, ())
self.assertTrue(t.is_complete())
self.assertEqual(
repr(t),
"enum_type(tag='color', type=int_type(name='unsigned int', size=4, is_signed=False), enumerators=())"
)
self.assertRaisesRegex(TypeError, 'must be Type', enum_type, 'color',
4, ())
self.assertRaisesRegex(ValueError, 'must be integer type', enum_type,
'color', void_type(), ())
self.assertRaisesRegex(
ValueError, 'must be unqualified', enum_type, 'color',
int_type('unsigned int', 4, True, Qualifiers.CONST), ())
self.assertRaisesRegex(ValueError, 'must not have compatible type',
enum_type, 'color',
int_type('unsigned int', 4, False), None)
self.assertRaisesRegex(ValueError, 'must have compatible type',
enum_type, 'color', None, ())
self.assertRaisesRegex(TypeError, 'must be sequence or None',
enum_type, 'color',
int_type('unsigned int', 4, False), 4)
self.assertRaisesRegex(TypeError, 'must be.*sequence',
enum_type, 'color',
int_type('unsigned int', 4, False), (4, ))
self.assertRaisesRegex(ValueError, 'must be.*sequence',
enum_type, 'color',
int_type('unsigned int', 4, False), ((), ))
self.assertRaisesRegex(TypeError, 'must be string', enum_type, 'color',
int_type('unsigned int', 4, False),
((None, 0), ))
self.assertRaisesRegex(TypeError, 'must be integer', enum_type,
'color', int_type('unsigned int', 4,
False), (('RED', None), ))
def test_wrong_kind(self):
prog = mock_program()
prog.add_type_finder(lambda kind, name, filename: void_type())
self.assertRaises(TypeError, prog.type, 'int')
def test_function(self):
t = function_type(void_type(),
(TypeParameter(int_type("int", 4, True), "n"), ))
self.assertEqual(t.kind, TypeKind.FUNCTION)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t.type, void_type())
self.assertEqual(t.parameters,
(TypeParameter(int_type("int", 4, True), "n"), ))
self.assertFalse(t.is_variadic)
self.assertTrue(t.is_complete())
self.assertEqual(
t,
function_type(void_type(),
(TypeParameter(int_type("int", 4, True), "n"), )),
)
# Different return type.
self.assertNotEqual(
t,
function_type(
int_type("int", 4, True),
(TypeParameter(int_type("int", 4, True), "n"), ),
),
)
# Different parameter name.
self.assertNotEqual(
t,
function_type(void_type(),
(TypeParameter(int_type("int", 4, True), "x"), )),
)
# Unnamed parameter.
self.assertNotEqual(
t,
function_type(void_type(),
(TypeParameter(int_type("int", 4, True), ), )))
# Different number of parameters.
self.assertNotEqual(
t,
function_type(
void_type(),
(
TypeParameter(int_type("int", 4, True), "n"),
TypeParameter(pointer_type(8, void_type()), "p"),
),
),
)
# One is variadic.
self.assertNotEqual(
t,
function_type(void_type(),
(TypeParameter(int_type("int", 4, True), "n"), ),
True),
)
self.assertEqual(
repr(t),
"function_type(type=void_type(), parameters=(TypeParameter(type=int_type(name='int', size=4, is_signed=True), name='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 TypeParameter",
function_type, void_type(), (4, ))
