def test_pointer_to_function(self):
i = self.prog.int_type("int", 4, True)
self.assertTypeName(
self.prog.pointer_type(
self.prog.function_type(i, (TypeParameter(i),), False)
),
"int (*)(int)",
True,
)
self.assertTypeName(
self.prog.pointer_type(
self.prog.function_type(i, (TypeParameter(i, "x"),), False)
),
"int (*)(int x)",
True,
)
self.assertTypeName(
self.prog.pointer_type(
self.prog.function_type(
i,
(
TypeParameter(i),
TypeParameter(self.prog.float_type("float", 4)),
),
False,
),
),
"int (*)(int, float)",
True,
)
def test_callable(self):
p = TypeParameter(self.prog.void_type)
self.assertIdentical(p.type, self.prog.void_type())
p = TypeParameter(lambda: self.prog.int_type("int", 4, True))
self.assertIdentical(p.type, self.prog.int_type("int", 4, True))
p = TypeParameter(lambda: None)
self.assertRaises(TypeError, getattr, p, "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_repr(self):
p = TypeParameter(self.prog.void_type, name="foo")
self.assertEqual(repr(p),
"TypeParameter(prog.type('void'), name='foo')")
p = TypeParameter(self.prog.void_type)
self.assertEqual(repr(p), "TypeParameter(prog.type('void'))")
p = TypeParameter(lambda: None)
self.assertRaises(TypeError, repr, p)
def test_init(self):
p = TypeParameter(self.prog.void_type())
self.assertIdentical(p.type, self.prog.void_type())
self.assertIsNone(p.name)
p = TypeParameter(self.prog.void_type(), "foo")
self.assertIdentical(p.type, self.prog.void_type())
self.assertEqual(p.name, "foo")
self.assertRaises(TypeError, TypeParameter, None)
self.assertRaises(TypeError, TypeParameter, self.prog.void_type(), 1)
def test_different_programs_function_parameter_callback(self):
with self.assertRaisesRegex(ValueError,
"type is from different program"):
self.prog.function_type(
self.prog.void_type(),
(TypeParameter(lambda: Program().int_type("int", 4, True)), ),
).parameters[0].type
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_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_init(self):
p = TypeParameter(self.prog.void_type())
self.assertIdentical(p.default_argument,
Object(self.prog, self.prog.void_type()))
self.assertIdentical(p.type, self.prog.void_type())
self.assertIsNone(p.name)
p = TypeParameter(
Object(self.prog, self.prog.int_type("int", 4, True), 5), "foo")
self.assertIdentical(
p.default_argument,
Object(self.prog, self.prog.int_type("int", 4, True), 5))
self.assertIdentical(p.type, self.prog.int_type("int", 4, True))
self.assertEqual(p.name, "foo")
self.assertRaises(TypeError, TypeParameter, None)
self.assertRaises(TypeError, TypeParameter, self.prog.void_type(), 1)
def test_different_programs_function_parameter(self):
self.assertRaisesRegex(
ValueError,
"object is from different program",
self.prog.function_type,
self.prog.void_type(),
(TypeParameter(mock_program().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, (TypeParameter(i),), False))
),
"int (*[4])(int)",
True,
)
def test_function(self):
t = self.prog.function_type(
self.prog.void_type(),
(TypeParameter(self.prog.int_type("int", 4, True), "n"), ),
)
self.assertEqual(t.kind, TypeKind.FUNCTION)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertIdentical(t.type, self.prog.void_type())
self.assertIdentical(
t.parameters,
(TypeParameter(self.prog.int_type("int", 4, True), "n"), ))
self.assertFalse(t.is_variadic)
self.assertTrue(t.is_complete())
self.assertEqual(
repr(t),
"prog.function_type(type=prog.void_type(), parameters=(TypeParameter(prog.type('int'), name='n'),), is_variadic=False)",
)
self.assertRaises(TypeError, sizeof, t)
self.assertFalse(
self.prog.function_type(self.prog.void_type(), (),
False).is_variadic)
self.assertTrue(
self.prog.function_type(self.prog.void_type(), (),
True).is_variadic)
self.assertRaisesRegex(TypeError, r"must be _drgn\.Type",
self.prog.function_type, None, ())
self.assertRaisesRegex(
TypeError,
"must be sequence",
self.prog.function_type,
self.prog.void_type(),
None,
)
self.assertRaisesRegex(
TypeError,
"must be TypeParameter",
self.prog.function_type,
self.prog.void_type(),
(4, ),
)
def test_pointer_to_function_returning_pointer(self):
i = int_type("int", 4, True)
self.assertTypeName(
pointer_type(
8,
function_type(pointer_type(8, i), (TypeParameter(i), ),
False)),
"int *(*)(int)",
True,
)
self.assertTypeName(
pointer_type(
8,
function_type(pointer_type(8, i),
(TypeParameter(pointer_type(8, i)), ), False),
),
"int *(*)(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, (TypeParameter(i), ), False),
Qualifiers.CONST),
),
"int (* const [])(int)",
True,
)
def test_const_pointer_to_function_returning_pointer(self):
i = int_type("int", 4, True)
self.assertTypeName(
pointer_type(
8,
function_type(pointer_type(8, i), (TypeParameter(i), ), False),
Qualifiers.CONST,
),
"int *(* const)(int)",
True,
)
def test_array_of_const_pointers_to_functions(self):
i = self.prog.int_type("int", 4, True)
self.assertTypeName(
self.prog.array_type(
self.prog.pointer_type(
self.prog.function_type(i, (TypeParameter(i),), False),
qualifiers=Qualifiers.CONST,
),
),
"int (* const [])(int)",
True,
)
def test_pointer_to_function_returning_const_pointer(self):
i = self.prog.int_type("int", 4, True)
self.assertTypeName(
self.prog.pointer_type(
self.prog.function_type(
self.prog.pointer_type(i, qualifiers=Qualifiers.CONST),
(TypeParameter(i),),
False,
),
),
"int * const (*)(int)",
True,
)
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, ))