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, ))