Debian Codegraph @

tests/test_type.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 from drgn import (
5 Architecture,
6 Language,
7 NoDefaultProgramError,
8 Object,
9 Platform,
10 PrimitiveType,
11 Program,
12 Qualifiers,
13 TypeEnumerator,
14 TypeKind,
15 TypeMember,
16 TypeParameter,
17 TypeTemplateParameter,
18 alignof,
19 offsetof,
20 sizeof,
21 )
22 from tests import (
23 DEFAULT_LANGUAGE,
24 MockProgramTestCase,
25 TestCase,
26 assertReprPrettyEqualsStr,
27 mock_program,
28 with_default_prog,
29 )
30
31
32 class TestType(MockProgramTestCase):
33 def test_void(self):
34 t = self.prog.void_type()
35 self.assertEqual(t.kind, TypeKind.VOID)
36 self.assertEqual(t.primitive, PrimitiveType.C_VOID)
37 self.assertEqual(t.language, DEFAULT_LANGUAGE)
38 self.assertIdentical(t, self.prog.void_type())
39 self.assertFalse(t.is_complete())
40 self.assertEqual(repr(t), "prog.void_type()")
41
42 def test_int(self):
43 t = self.prog.int_type("int", 4, True)
44 self.assertEqual(t.kind, TypeKind.INT)
45 self.assertEqual(t.primitive, PrimitiveType.C_INT)
46 self.assertEqual(t.language, DEFAULT_LANGUAGE)
47 self.assertEqual(t.name, "int")
48 self.assertEqual(t.size, 4)
49 self.assertTrue(t.is_signed)
50 self.assertEqual(t.byteorder, "little")
51 self.assertTrue(t.is_complete())
52
53 self.assertEqual(repr(t), "prog.int_type(name='int', size=4, is_signed=True)")
54 self.assertEqual(sizeof(t), 4)
55
56 self.assertRaises(TypeError, self.prog.int_type, None, 4, True)
57
58 self.assertIsNone(self.prog.int_type("my_int", 4, True).primitive)
59 self.assertIsNone(self.prog.int_type("int", 4, False).primitive)
60
61 def test_int_byteorder(self):
62 self.assertIdentical(
63 self.prog.int_type("int", 4, True),
64 self.prog.int_type("int", 4, True, byteorder="little"),
65 )
66 t = self.prog.int_type("int", 4, True, "big")
67 self.assertEqual(t.byteorder, "big")
68 self.assertEqual(
69 repr(t),
70 "prog.int_type(name='int', size=4, is_signed=True, byteorder='big')",
71 )
72 self.assertRaises(ValueError, self.prog.int_type, "int", 4, True, "middle")
73
74 def test_bool(self):
75 t = self.prog.bool_type("_Bool", 1)
76 self.assertEqual(t.kind, TypeKind.BOOL)
77 self.assertEqual(t.primitive, PrimitiveType.C_BOOL)
78 self.assertEqual(t.language, DEFAULT_LANGUAGE)
79 self.assertEqual(t.name, "_Bool")
80 self.assertEqual(t.size, 1)
81 self.assertEqual(t.byteorder, "little")
82 self.assertTrue(t.is_complete())
83
84 self.assertEqual(repr(t), "prog.bool_type(name='_Bool', size=1)")
85 self.assertEqual(sizeof(t), 1)
86
87 self.assertRaises(TypeError, self.prog.bool_type, None, 1)
88
89 def test_bool_byteorder(self):
90 self.assertIdentical(
91 self.prog.bool_type("_Bool", 1),
92 self.prog.bool_type("_Bool", 1, byteorder="little"),
93 )
94 t = self.prog.bool_type("_Bool", 1, "big")
95 self.assertEqual(t.byteorder, "big")
96 self.assertEqual(
97 repr(t), "prog.bool_type(name='_Bool', size=1, byteorder='big')"
98 )
99 self.assertRaises(ValueError, self.prog.bool_type, "_Bool", 1, "middle")
100
101 def test_float(self):
102 t = self.prog.float_type("float", 4)
103 self.assertEqual(t.primitive, PrimitiveType.C_FLOAT)
104 self.assertEqual(t.kind, TypeKind.FLOAT)
105 self.assertEqual(t.name, "float")
106 self.assertEqual(t.size, 4)
107 self.assertEqual(t.byteorder, "little")
108 self.assertTrue(t.is_complete())
109
110 self.assertEqual(repr(t), "prog.float_type(name='float', size=4)")
111 self.assertEqual(sizeof(t), 4)
112
113 self.assertRaises(TypeError, self.prog.float_type, None, 4)
114
115 def test_float_byteorder(self):
116 self.assertIdentical(
117 self.prog.bool_type("float", 1),
118 self.prog.bool_type("float", 1, byteorder="little"),
119 )
120 t = self.prog.float_type("float", 4, "big")
121 self.assertEqual(t.byteorder, "big")
122 self.assertEqual(
123 repr(t), "prog.float_type(name='float', size=4, byteorder='big')"
124 )
125 self.assertRaises(ValueError, self.prog.float_type, "float", 4, "middle")
126
127 def test_struct(self):
128 t = self.prog.struct_type(
129 "point",
130 8,
131 (
132 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
133 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
134 ),
135 )
136 self.assertEqual(t.kind, TypeKind.STRUCT)
137 self.assertIsNone(t.primitive)
138 self.assertEqual(t.language, DEFAULT_LANGUAGE)
139 self.assertEqual(t.tag, "point")
140 self.assertEqual(t.size, 8)
141 self.assertIdentical(
142 t.members,
143 (
144 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
145 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
146 ),
147 )
148 self.assertTrue(t.is_complete())
149
150 self.assertEqual(
151 repr(t),
152 "prog.struct_type(tag='point', size=8, members=(TypeMember(prog.type('int'), name='x', bit_offset=0), TypeMember(prog.type('int'), name='y', bit_offset=32)))",
153 )
154 self.assertEqual(sizeof(t), 8)
155
156 t = self.prog.struct_type(
157 None,
158 8,
159 (
160 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
161 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
162 ),
163 )
164 self.assertEqual(t.kind, TypeKind.STRUCT)
165 self.assertIsNone(t.primitive)
166 self.assertIsNone(t.tag)
167 self.assertEqual(t.size, 8)
168 self.assertIdentical(
169 t.members,
170 (
171 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
172 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
173 ),
174 )
175 self.assertTrue(t.is_complete())
176
177 t = self.prog.struct_type("color", 0, ())
178 self.assertEqual(t.kind, TypeKind.STRUCT)
179 self.assertIsNone(t.primitive)
180 self.assertEqual(t.tag, "color")
181 self.assertEqual(t.size, 0)
182 self.assertEqual(t.members, ())
183 self.assertTrue(t.is_complete())
184 self.assertEqual(repr(t), "prog.struct_type(tag='color', size=0, members=())")
185
186 t = self.prog.struct_type("color")
187 self.assertEqual(t.kind, TypeKind.STRUCT)
188 self.assertIsNone(t.primitive)
189 self.assertEqual(t.tag, "color")
190 self.assertIsNone(t.size)
191 self.assertIsNone(t.members)
192 self.assertFalse(t.is_complete())
193 self.assertEqual(
194 repr(t), "prog.struct_type(tag='color', size=None, members=None)"
195 )
196
197 t = self.prog.struct_type(None, None, None)
198 self.assertEqual(t.kind, TypeKind.STRUCT)
199 self.assertIsNone(t.primitive)
200 self.assertEqual(t.tag, None)
201 self.assertIsNone(t.size)
202 self.assertIsNone(t.members)
203 self.assertFalse(t.is_complete())
204 self.assertEqual(repr(t), "prog.struct_type(tag=None, size=None, members=None)")
205
206 self.assertRaises(TypeError, self.prog.struct_type, 4)
207 self.assertRaisesRegex(
208 ValueError, "must not have size", self.prog.struct_type, "point", 8, None
209 )
210 self.assertRaisesRegex(
211 ValueError, "must have size", self.prog.struct_type, "point", None, ()
212 )
213 self.assertRaisesRegex(
214 TypeError, "must be sequence or None", self.prog.struct_type, "point", 8, 4
215 )
216 self.assertRaisesRegex(
217 TypeError, "must be TypeMember", self.prog.struct_type, "point", 8, (4,)
218 )
219
220 # Bit size.
221 t = self.prog.struct_type(
222 "point",
223 8,
224 (
225 TypeMember(
226 Object(
227 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
228 ),
229 "x",
230 0,
231 ),
232 TypeMember(
233 Object(
234 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
235 ),
236 "y",
237 32,
238 ),
239 ),
240 )
241 self.assertIdentical(
242 t.members,
243 (
244 TypeMember(
245 Object(
246 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
247 ),
248 "x",
249 0,
250 ),
251 TypeMember(
252 Object(
253 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
254 ),
255 "y",
256 32,
257 ),
258 ),
259 )
260
261 def test_union(self):
262 t = self.prog.union_type(
263 "option",
264 4,
265 (
266 TypeMember(self.prog.int_type("int", 4, True), "x"),
267 TypeMember(self.prog.int_type("unsigned int", 4, False), "y"),
268 ),
269 )
270 self.assertEqual(t.kind, TypeKind.UNION)
271 self.assertIsNone(t.primitive)
272 self.assertEqual(t.language, DEFAULT_LANGUAGE)
273 self.assertEqual(t.tag, "option")
274 self.assertEqual(t.size, 4)
275 self.assertIdentical(
276 t.members,
277 (
278 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
279 TypeMember(self.prog.int_type("unsigned int", 4, False), "y", 0),
280 ),
281 )
282 self.assertTrue(t.is_complete())
283
284 self.assertEqual(
285 repr(t),
286 "prog.union_type(tag='option', size=4, members=(TypeMember(prog.type('int'), name='x', bit_offset=0), TypeMember(prog.type('unsigned int'), name='y', bit_offset=0)))",
287 )
288 self.assertEqual(sizeof(t), 4)
289
290 t = self.prog.union_type(
291 None,
292 4,
293 (
294 TypeMember(self.prog.int_type("int", 4, True), "x"),
295 TypeMember(self.prog.int_type("unsigned int", 4, False), "y"),
296 ),
297 )
298 self.assertEqual(t.kind, TypeKind.UNION)
299 self.assertIsNone(t.primitive)
300 self.assertIsNone(t.tag)
301 self.assertEqual(t.size, 4)
302 self.assertIdentical(
303 t.members,
304 (
305 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
306 TypeMember(self.prog.int_type("unsigned int", 4, False), "y", 0),
307 ),
308 )
309 self.assertTrue(t.is_complete())
310
311 t = self.prog.union_type("color", 0, ())
312 self.assertEqual(t.kind, TypeKind.UNION)
313 self.assertIsNone(t.primitive)
314 self.assertEqual(t.tag, "color")
315 self.assertEqual(t.size, 0)
316 self.assertEqual(t.members, ())
317 self.assertTrue(t.is_complete())
318 self.assertEqual(repr(t), "prog.union_type(tag='color', size=0, members=())")
319
320 t = self.prog.union_type("color")
321 self.assertEqual(t.kind, TypeKind.UNION)
322 self.assertIsNone(t.primitive)
323 self.assertEqual(t.tag, "color")
324 self.assertIsNone(t.size)
325 self.assertIsNone(t.members)
326 self.assertFalse(t.is_complete())
327 self.assertEqual(
328 repr(t), "prog.union_type(tag='color', size=None, members=None)"
329 )
330
331 t = self.prog.union_type(None, None, None)
332 self.assertEqual(t.kind, TypeKind.UNION)
333 self.assertIsNone(t.primitive)
334 self.assertEqual(t.tag, None)
335 self.assertIsNone(t.size)
336 self.assertIsNone(t.members)
337 self.assertFalse(t.is_complete())
338 self.assertEqual(repr(t), "prog.union_type(tag=None, size=None, members=None)")
339
340 self.assertRaises(TypeError, self.prog.union_type, 4)
341 self.assertRaisesRegex(
342 ValueError, "must not have size", self.prog.union_type, "option", 8, None
343 )
344 self.assertRaisesRegex(
345 ValueError, "must have size", self.prog.union_type, "option", None, ()
346 )
347 self.assertRaisesRegex(
348 TypeError, "must be sequence or None", self.prog.union_type, "option", 8, 4
349 )
350 self.assertRaisesRegex(
351 TypeError, "must be TypeMember", self.prog.union_type, "option", 8, (4,)
352 )
353
354 # Bit size.
355 t = self.prog.union_type(
356 "option",
357 4,
358 (
359 TypeMember(
360 Object(
361 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
362 ),
363 "x",
364 0,
365 ),
366 TypeMember(
367 Object(
368 self.prog,
369 self.prog.int_type("unsigned int", 4, False),
370 bit_field_size=4,
371 ),
372 "y",
373 0,
374 ),
375 ),
376 )
377 self.assertIdentical(
378 t.members,
379 (
380 TypeMember(
381 Object(
382 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
383 ),
384 "x",
385 0,
386 ),
387 TypeMember(
388 Object(
389 self.prog,
390 self.prog.int_type("unsigned int", 4, False),
391 bit_field_size=4,
392 ),
393 "y",
394 0,
395 ),
396 ),
397 )
398
399 def test_class(self):
400 t = self.prog.class_type(
401 "coord",
402 12,
403 (
404 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
405 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
406 TypeMember(self.prog.int_type("int", 4, True), "z", 64),
407 ),
408 )
409 self.assertEqual(t.kind, TypeKind.CLASS)
410 self.assertIsNone(t.primitive)
411 self.assertEqual(t.language, DEFAULT_LANGUAGE)
412 self.assertEqual(t.tag, "coord")
413 self.assertEqual(t.size, 12)
414 self.assertIdentical(
415 t.members,
416 (
417 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
418 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
419 TypeMember(self.prog.int_type("int", 4, True), "z", 64),
420 ),
421 )
422 self.assertTrue(t.is_complete())
423
424 self.assertEqual(
425 repr(t),
426 "prog.class_type(tag='coord', size=12, members=(TypeMember(prog.type('int'), name='x', bit_offset=0), TypeMember(prog.type('int'), name='y', bit_offset=32), TypeMember(prog.type('int'), name='z', bit_offset=64)))",
427 )
428 self.assertEqual(sizeof(t), 12)
429
430 t = self.prog.class_type(
431 None,
432 12,
433 (
434 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
435 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
436 TypeMember(self.prog.int_type("int", 4, True), "z", 64),
437 ),
438 )
439 self.assertEqual(t.kind, TypeKind.CLASS)
440 self.assertIsNone(t.primitive)
441 self.assertIsNone(t.tag)
442 self.assertEqual(t.size, 12)
443 self.assertIdentical(
444 t.members,
445 (
446 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
447 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
448 TypeMember(self.prog.int_type("int", 4, True), "z", 64),
449 ),
450 )
451 self.assertTrue(t.is_complete())
452
453 t = self.prog.class_type("color", 0, ())
454 self.assertEqual(t.kind, TypeKind.CLASS)
455 self.assertIsNone(t.primitive)
456 self.assertEqual(t.tag, "color")
457 self.assertEqual(t.size, 0)
458 self.assertEqual(t.members, ())
459 self.assertTrue(t.is_complete())
460 self.assertEqual(repr(t), "prog.class_type(tag='color', size=0, members=())")
461
462 t = self.prog.class_type("color")
463 self.assertEqual(t.kind, TypeKind.CLASS)
464 self.assertIsNone(t.primitive)
465 self.assertEqual(t.tag, "color")
466 self.assertIsNone(t.size)
467 self.assertIsNone(t.members)
468 self.assertFalse(t.is_complete())
469 self.assertEqual(
470 repr(t), "prog.class_type(tag='color', size=None, members=None)"
471 )
472
473 t = self.prog.class_type(None, None, None)
474 self.assertEqual(t.kind, TypeKind.CLASS)
475 self.assertIsNone(t.primitive)
476 self.assertEqual(t.tag, None)
477 self.assertIsNone(t.size)
478 self.assertIsNone(t.members)
479 self.assertFalse(t.is_complete())
480 self.assertEqual(repr(t), "prog.class_type(tag=None, size=None, members=None)")
481
482 self.assertRaises(TypeError, self.prog.class_type, 4)
483 self.assertRaisesRegex(
484 ValueError, "must not have size", self.prog.class_type, "coord", 12, None
485 )
486 self.assertRaisesRegex(
487 ValueError, "must have size", self.prog.class_type, "coord", None, ()
488 )
489 self.assertRaisesRegex(
490 TypeError, "must be sequence or None", self.prog.class_type, "coord", 12, 4
491 )
492 self.assertRaisesRegex(
493 TypeError, "must be TypeMember", self.prog.class_type, "coord", 12, (4,)
494 )
495
496 # Bit size.
497 t = self.prog.class_type(
498 "coord",
499 12,
500 (
501 TypeMember(
502 Object(
503 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
504 ),
505 "x",
506 0,
507 ),
508 TypeMember(
509 Object(
510 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
511 ),
512 "y",
513 32,
514 ),
515 TypeMember(
516 Object(
517 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
518 ),
519 "z",
520 64,
521 ),
522 ),
523 )
524 self.assertIdentical(
525 t.members,
526 (
527 TypeMember(
528 Object(
529 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
530 ),
531 "x",
532 0,
533 ),
534 TypeMember(
535 Object(
536 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
537 ),
538 "y",
539 32,
540 ),
541 TypeMember(
542 Object(
543 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
544 ),
545 "z",
546 64,
547 ),
548 ),
549 )
550
551 def test_member(self):
552 t = self.prog.struct_type(
553 None,
554 8,
555 (
556 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
557 TypeMember(
558 self.prog.struct_type(
559 None,
560 4,
561 (TypeMember(self.prog.int_type("int", 4, True), "y", 0),),
562 ),
563 None,
564 32,
565 ),
566 ),
567 )
568 self.assertIdentical(
569 t.member("x"), TypeMember(self.prog.int_type("int", 4, True), "x", 0)
570 )
571 self.assertIdentical(
572 t.member("y"), TypeMember(self.prog.int_type("int", 4, True), "y", 32)
573 )
574 self.assertRaises(LookupError, t.member, "z")
575
576 self.assertIdentical(
577 t.members[1].type.member("y"),
578 TypeMember(self.prog.int_type("int", 4, True), "y", 0),
579 )
580
581 self.assertRaises(TypeError, self.prog.int_type("int", 4, True).member, "foo")
582
583 def test_offsetof(self):
584 self.assertEqual(offsetof(self.line_segment_type, "b"), 8)
585 self.assertEqual(offsetof(self.line_segment_type, "a.y"), 4)
586 self.assertRaisesRegex(
587 LookupError,
588 "'struct line_segment' has no member 'c'",
589 offsetof,
590 self.line_segment_type,
591 "c.x",
592 )
593
594 small_point_type = self.prog.struct_type(
595 "small_point",
596 1,
597 (
598 TypeMember(
599 Object(
600 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
601 ),
602 "x",
603 0,
604 ),
605 TypeMember(
606 Object(
607 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
608 ),
609 "y",
610 4,
611 ),
612 ),
613 )
614 self.assertEqual(offsetof(small_point_type, "x"), 0)
615 self.assertRaisesRegex(
616 ValueError,
617 "member is not byte-aligned",
618 offsetof,
619 small_point_type,
620 "y",
621 )
622 self.assertRaisesRegex(
623 SyntaxError,
624 "expected identifier",
625 offsetof,
626 self.prog.array_type(self.prog.int_type("int", 4, True), 10),
627 "[1]",
628 )
629
630 def test_enum(self):
631 t = self.prog.enum_type(
632 "color",
633 self.prog.int_type("unsigned int", 4, False),
634 (
635 TypeEnumerator("RED", 0),
636 TypeEnumerator("GREEN", 1),
637 TypeEnumerator("BLUE", 2),
638 ),
639 )
640 self.assertEqual(t.kind, TypeKind.ENUM)
641 self.assertIsNone(t.primitive)
642 self.assertEqual(t.language, DEFAULT_LANGUAGE)
643 self.assertEqual(t.tag, "color")
644 self.assertIdentical(t.type, self.prog.int_type("unsigned int", 4, False))
645 self.assertEqual(
646 t.enumerators,
647 (
648 TypeEnumerator("RED", 0),
649 TypeEnumerator("GREEN", 1),
650 TypeEnumerator("BLUE", 2),
651 ),
652 )
653 self.assertTrue(t.is_complete())
654
655 self.assertEqual(
656 repr(t),
657 "prog.enum_type(tag='color', type=prog.int_type(name='unsigned int', size=4, is_signed=False), enumerators=(TypeEnumerator('RED', 0), TypeEnumerator('GREEN', 1), TypeEnumerator('BLUE', 2)))",
658 )
659 self.assertEqual(sizeof(t), 4)
660
661 t = self.prog.enum_type("color", None, None)
662 self.assertEqual(t.kind, TypeKind.ENUM)
663 self.assertIsNone(t.primitive)
664 self.assertEqual(t.tag, "color")
665 self.assertIsNone(t.type)
666 self.assertIsNone(t.enumerators)
667 self.assertFalse(t.is_complete())
668
669 self.assertEqual(
670 repr(t), "prog.enum_type(tag='color', type=None, enumerators=None)"
671 )
672
673 # A type with no enumerators isn't valid in C, but we allow it.
674 t = self.prog.enum_type(
675 "color", self.prog.int_type("unsigned int", 4, False), ()
676 )
677 self.assertEqual(t.kind, TypeKind.ENUM)
678 self.assertIsNone(t.primitive)
679 self.assertEqual(t.tag, "color")
680 self.assertIdentical(t.type, self.prog.int_type("unsigned int", 4, False))
681 self.assertEqual(t.enumerators, ())
682 self.assertTrue(t.is_complete())
683
684 self.assertEqual(
685 repr(t),
686 "prog.enum_type(tag='color', type=prog.int_type(name='unsigned int', size=4, is_signed=False), enumerators=())",
687 )
688
689 self.assertRaisesRegex(
690 TypeError, "must be Type", self.prog.enum_type, "color", 4, ()
691 )
692 self.assertRaisesRegex(
693 ValueError,
694 "must be integer type",
695 self.prog.enum_type,
696 "color",
697 self.prog.void_type(),
698 (),
699 )
700 self.assertRaisesRegex(
701 ValueError,
702 "must be unqualified",
703 self.prog.enum_type,
704 "color",
705 self.prog.int_type("unsigned int", 4, True, qualifiers=Qualifiers.CONST),
706 (),
707 )
708 self.assertRaisesRegex(
709 ValueError,
710 "must not have compatible type",
711 self.prog.enum_type,
712 "color",
713 self.prog.int_type("unsigned int", 4, False),
714 None,
715 )
716 self.assertRaisesRegex(
717 ValueError,
718 "must have compatible type",
719 self.prog.enum_type,
720 "color",
721 None,
722 (),
723 )
724 self.assertRaisesRegex(
725 TypeError,
726 "must be sequence or None",
727 self.prog.enum_type,
728 "color",
729 self.prog.int_type("unsigned int", 4, False),
730 4,
731 )
732 self.assertRaisesRegex(
733 TypeError,
734 "must be TypeEnumerator",
735 self.prog.enum_type,
736 "color",
737 self.prog.int_type("unsigned int", 4, False),
738 (4,),
739 )
740
741 def test_typedef(self):
742 t = self.prog.typedef_type("INT", self.prog.int_type("int", 4, True))
743 self.assertEqual(t.kind, TypeKind.TYPEDEF)
744 self.assertIsNone(t.primitive)
745 self.assertEqual(t.language, DEFAULT_LANGUAGE)
746 self.assertEqual(t.name, "INT")
747 self.assertIdentical(t.type, self.prog.int_type("int", 4, True))
748 self.assertTrue(t.is_complete())
749
750 self.assertEqual(
751 repr(t),
752 "prog.typedef_type(name='INT', type=prog.int_type(name='int', size=4, is_signed=True))",
753 )
754 self.assertEqual(sizeof(t), 4)
755
756 t = self.prog.typedef_type("VOID", self.prog.void_type())
757 self.assertFalse(t.is_complete())
758
759 self.assertRaises(
760 TypeError, self.prog.typedef_type, None, self.prog.int_type("int", 4, True)
761 )
762 self.assertRaises(TypeError, self.prog.typedef_type, "INT", 4)
763
764 self.assertEqual(
765 self.prog.typedef_type(
766 "size_t", self.prog.int_type("unsigned long", 8, False)
767 ).primitive,
768 PrimitiveType.C_SIZE_T,
769 )
770 self.assertEqual(
771 self.prog.typedef_type(
772 "ptrdiff_t", self.prog.int_type("long", 8, True)
773 ).primitive,
774 PrimitiveType.C_PTRDIFF_T,
775 )
776
777 def test_pointer(self):
778 t = self.prog.pointer_type(self.prog.int_type("int", 4, True), 8)
779 self.assertEqual(t.kind, TypeKind.POINTER)
780 self.assertIsNone(t.primitive)
781 self.assertEqual(t.language, DEFAULT_LANGUAGE)
782 self.assertEqual(t.size, 8)
783 self.assertIdentical(t.type, self.prog.int_type("int", 4, True))
784 self.assertEqual(t.byteorder, "little")
785 self.assertTrue(t.is_complete())
786
787 self.assertEqual(
788 repr(t),
789 "prog.pointer_type(type=prog.int_type(name='int', size=4, is_signed=True))",
790 )
791 self.assertEqual(
792 repr(self.prog.pointer_type(self.prog.int_type("int", 4, True), 4)),
793 "prog.pointer_type(type=prog.int_type(name='int', size=4, is_signed=True), size=4)",
794 )
795
796 self.assertEqual(sizeof(t), 8)
797
798 self.assertRaises(TypeError, self.prog.pointer_type, 4)
799
800 def test_pointer_byteorder(self):
801 self.assertIdentical(
802 self.prog.pointer_type(self.prog.int_type("int", 4, True)),
803 self.prog.pointer_type(
804 self.prog.int_type("int", 4, True), byteorder="little"
805 ),
806 )
807 t = self.prog.pointer_type(self.prog.int_type("int", 4, True), 8, "big")
808 self.assertEqual(t.byteorder, "big")
809 self.assertEqual(t.type.byteorder, "little")
810 self.assertEqual(
811 repr(t),
812 "prog.pointer_type(type=prog.int_type(name='int', size=4, is_signed=True), byteorder='big')",
813 )
814 self.assertRaises(
815 ValueError,
816 self.prog.pointer_type,
817 self.prog.int_type("int", 4, True),
818 8,
819 "middle",
820 )
821
822 def test_array(self):
823 t = self.prog.array_type(self.prog.int_type("int", 4, True), 10)
824 self.assertEqual(t.kind, TypeKind.ARRAY)
825 self.assertIsNone(t.primitive)
826 self.assertEqual(t.language, DEFAULT_LANGUAGE)
827 self.assertEqual(t.length, 10)
828 self.assertIdentical(t.type, self.prog.int_type("int", 4, True))
829 self.assertTrue(t.is_complete())
830
831 self.assertEqual(
832 repr(t),
833 "prog.array_type(type=prog.int_type(name='int', size=4, is_signed=True), length=10)",
834 )
835 self.assertEqual(sizeof(t), 40)
836
837 t = self.prog.array_type(self.prog.int_type("int", 4, True), 0)
838 self.assertEqual(t.kind, TypeKind.ARRAY)
839 self.assertIsNone(t.primitive)
840 self.assertEqual(t.length, 0)
841 self.assertIdentical(t.type, self.prog.int_type("int", 4, True))
842 self.assertTrue(t.is_complete())
843
844 t = self.prog.array_type(self.prog.int_type("int", 4, True))
845 self.assertEqual(t.kind, TypeKind.ARRAY)
846 self.assertIsNone(t.primitive)
847 self.assertIsNone(t.length)
848 self.assertIdentical(t.type, self.prog.int_type("int", 4, True))
849 self.assertFalse(t.is_complete())
850
851 self.assertRaises(TypeError, self.prog.array_type, 10, 4)
852
853 def test_function(self):
854 t = self.prog.function_type(
855 self.prog.void_type(),
856 (TypeParameter(self.prog.int_type("int", 4, True), "n"),),
857 )
858 self.assertEqual(t.kind, TypeKind.FUNCTION)
859 self.assertIsNone(t.primitive)
860 self.assertEqual(t.language, DEFAULT_LANGUAGE)
861 self.assertIdentical(t.type, self.prog.void_type())
862 self.assertIdentical(
863 t.parameters, (TypeParameter(self.prog.int_type("int", 4, True), "n"),)
864 )
865 self.assertFalse(t.is_variadic)
866 self.assertTrue(t.is_complete())
867
868 self.assertEqual(
869 repr(t),
870 "prog.function_type(type=prog.void_type(), parameters=(TypeParameter(prog.type('int'), name='n'),), is_variadic=False)",
871 )
872 self.assertRaises(TypeError, sizeof, t)
873
874 self.assertFalse(
875 self.prog.function_type(self.prog.void_type(), (), False).is_variadic
876 )
877 self.assertTrue(
878 self.prog.function_type(self.prog.void_type(), (), True).is_variadic
879 )
880
881 self.assertRaisesRegex(
882 TypeError, r"must be _drgn\.Type", self.prog.function_type, None, ()
883 )
884 self.assertRaisesRegex(
885 TypeError,
886 "must be sequence",
887 self.prog.function_type,
888 self.prog.void_type(),
889 None,
890 )
891 self.assertRaisesRegex(
892 TypeError,
893 "must be TypeParameter",
894 self.prog.function_type,
895 self.prog.void_type(),
896 (4,),
897 )
898
899 def test_cycle(self):
900 t1 = self.prog.struct_type(
901 "foo", 8, (TypeMember(lambda: self.prog.pointer_type(t1), "next"),)
902 )
903 t2 = self.prog.struct_type(
904 "foo", 8, (TypeMember(lambda: self.prog.pointer_type(t2), "next"),)
905 )
906 t3, t4 = (
907 self.prog.struct_type(
908 "foo", 8, (TypeMember(lambda: self.prog.pointer_type(t4), "next"),)
909 ),
910 self.prog.struct_type(
911 "foo", 8, (TypeMember(lambda: self.prog.pointer_type(t3), "next"),)
912 ),
913 )
914 self.assertIdentical(t1, t2)
915 self.assertIdentical(t2, t3)
916 self.assertIdentical(t3, t4)
917
918 self.assertEqual(
919 repr(t1),
920 "prog.struct_type(tag='foo', size=8, members=(TypeMember(prog.type('struct foo *'), name='next', bit_offset=0),))",
921 )
922
923 def test_cycle2(self):
924 t1 = self.prog.struct_type(
925 "list_head",
926 16,
927 (
928 TypeMember(lambda: self.prog.pointer_type(t1), "next"),
929 TypeMember(lambda: self.prog.pointer_type(t1), "prev", 8),
930 ),
931 )
932 t2 = self.prog.struct_type(
933 "list_head",
934 16,
935 (
936 TypeMember(lambda: self.prog.pointer_type(t2), "next"),
937 TypeMember(lambda: self.prog.pointer_type(t2), "prev", 8),
938 ),
939 )
940 self.assertIdentical(t1, t2)
941
942 self.assertEqual(
943 repr(t1),
944 "prog.struct_type(tag='list_head', size=16, members=(TypeMember(prog.type('struct list_head *'), name='next', bit_offset=0), TypeMember(prog.type('struct list_head *'), name='prev', bit_offset=8)))",
945 )
946
947 def test_bad_thunk(self):
948 t1 = self.prog.struct_type(
949 "foo", 16, (TypeMember(lambda: exec('raise Exception("test")'), "bar"),)
950 )
951 with self.assertRaisesRegex(Exception, "test"):
952 t1.members[0].type
953 t1 = self.prog.struct_type("foo", 16, (TypeMember(lambda: 0, "bar"),))
954 with self.assertRaisesRegex(
955 TypeError, r"TypeMember\(\) callable must return Object or Type"
956 ):
957 t1.members[0].type
958
959 def test_qualifiers(self):
960 self.assertEqual(self.prog.void_type().qualifiers, Qualifiers(0))
961
962 t = self.prog.void_type(qualifiers=Qualifiers.CONST | Qualifiers.VOLATILE)
963 self.assertEqual(t.qualifiers, Qualifiers.CONST | Qualifiers.VOLATILE)
964 self.assertEqual(
965 repr(t),
966 f"prog.void_type(qualifiers={repr(Qualifiers.CONST | Qualifiers.VOLATILE)})",
967 )
968
969 self.assertIdentical(
970 t.qualified(Qualifiers.ATOMIC),
971 self.prog.void_type(qualifiers=Qualifiers.ATOMIC),
972 )
973 self.assertIdentical(t.unqualified(), self.prog.void_type())
974 self.assertIdentical(t.qualified(Qualifiers(0)), t.unqualified())
975
976 self.assertRaisesRegex(
977 TypeError, "expected Qualifiers", self.prog.void_type, qualifiers=1.5
978 )
979
980 def test_unaliased(self):
981 self.assertIdentical(
982 self.prog.typedef_type(
983 "loff_t",
984 self.prog.typedef_type(
985 "__kernel_loff_t",
986 self.prog.int_type("long long", 8, True),
987 ),
988 ).unaliased(),
989 self.prog.int_type("long long", 8, True),
990 )
991
992 def test_unalias_not_typedef(self):
993 self.assertIdentical(
994 self.prog.int_type("long long", 8, True).unaliased(),
995 self.prog.int_type("long long", 8, True),
996 )
997
998 def test_unalias_qualifiers(self):
999 self.assertIdentical(
1000 self.prog.typedef_type(
1001 "CINT",
1002 self.prog.int_type("int", 4, True, qualifiers=Qualifiers.CONST),
1003 qualifiers=Qualifiers.VOLATILE,
1004 ).unaliased(),
1005 self.prog.int_type(
1006 "int", 4, True, qualifiers=Qualifiers.CONST | Qualifiers.VOLATILE
1007 ),
1008 )
1009
1010 def test_unaliased_kind(self):
1011 self.assertEqual(
1012 self.prog.typedef_type(
1013 "loff_t",
1014 self.prog.typedef_type(
1015 "__kernel_loff_t",
1016 self.prog.int_type("long long", 8, True),
1017 ),
1018 ).unaliased_kind(),
1019 TypeKind.INT,
1020 )
1021
1022 def test_unaliased_kind_not_typedef(self):
1023 self.assertEqual(
1024 self.prog.int_type("long long", 8, True).unaliased_kind(),
1025 TypeKind.INT,
1026 )
1027
1028 def test_language(self):
1029 self.assertEqual(self.prog.void_type(language=None).language, DEFAULT_LANGUAGE)
1030 self.assertEqual(self.prog.void_type(language=Language.C).language, Language.C)
1031
1032 self.assertEqual(
1033 self.prog.int_type("int", 4, True, language=Language.CPP).language,
1034 Language.CPP,
1035 )
1036
1037 def test_language_repr(self):
1038 self.assertEqual(
1039 repr(self.prog.void_type(language=Language.CPP)),
1040 "prog.void_type(language=Language.CPP)",
1041 )
1042
1043 def test__repr_pretty_(self):
1044 t = self.prog.void_type()
1045 assertReprPrettyEqualsStr(t)
1046
1047 def test_different_programs_compound(self):
1048 self.assertRaisesRegex(
1049 ValueError,
1050 "object is from different program",
1051 self.prog.struct_type,
1052 None,
1053 4,
1054 (TypeMember(mock_program().int_type("int", 4, True)),),
1055 )
1056
1057 def test_different_programs_compound_callback(self):
1058 with self.assertRaisesRegex(ValueError, "objects are from different program"):
1059 self.prog.struct_type(
1060 None, 4, (TypeMember(lambda: mock_program().int_type("int", 4, True)),)
1061 ).members[0].type
1062
1063 def test_different_programs_enum(self):
1064 self.assertRaisesRegex(
1065 ValueError,
1066 "type is from different program",
1067 self.prog.enum_type,
1068 None,
1069 mock_program().int_type("int", 4, True),
1070 (),
1071 )
1072
1073 def test_different_programs_typedef(self):
1074 self.assertRaisesRegex(
1075 ValueError,
1076 "type is from different program",
1077 self.prog.typedef_type,
1078 "INT",
1079 mock_program().int_type("int", 4, True),
1080 )
1081
1082 def test_different_programs_pointer(self):
1083 self.assertRaisesRegex(
1084 ValueError,
1085 "type is from different program",
1086 self.prog.pointer_type,
1087 mock_program().int_type("int", 4, True),
1088 )
1089
1090 def test_different_programs_array(self):
1091 self.assertRaisesRegex(
1092 ValueError,
1093 "type is from different program",
1094 self.prog.pointer_type,
1095 mock_program().int_type("int", 4, True),
1096 )
1097
1098 def test_different_programs_function_return(self):
1099 self.assertRaisesRegex(
1100 ValueError,
1101 "type is from different program",
1102 self.prog.function_type,
1103 mock_program().int_type("int", 4, True),
1104 (),
1105 )
1106
1107 def test_different_programs_function_parameter(self):
1108 self.assertRaisesRegex(
1109 ValueError,
1110 "object is from different program",
1111 self.prog.function_type,
1112 self.prog.void_type(),
1113 (TypeParameter(mock_program().int_type("int", 4, True)),),
1114 )
1115
1116 def test_different_programs_function_parameter_callback(self):
1117 with self.assertRaisesRegex(ValueError, "objects are from different programs"):
1118 self.prog.function_type(
1119 self.prog.void_type(),
1120 (TypeParameter(lambda: mock_program().int_type("int", 4, True)),),
1121 ).parameters[0].type
1122
1123 def test_sizeof_default_prog(self):
1124 self.assertRaises(NoDefaultProgramError, sizeof, "int")
1125 with with_default_prog(self.prog):
1126 self.assertEqual(sizeof("int"), 4)
1127 self.assertRaises(LookupError, sizeof, "foo")
1128
1129 def test_offsetof_default_prog(self):
1130 self.types.append(self.point_type)
1131 self.assertRaises(NoDefaultProgramError, offsetof, "struct point", "y")
1132 with with_default_prog(self.prog):
1133 self.assertEqual(offsetof("struct point", "y"), 4)
1134 self.assertRaises(LookupError, offsetof, "struct foo", "y")
1135
1136
1137 class TestTypeEnumerator(MockProgramTestCase):
1138 def test_init(self):
1139 e = TypeEnumerator("a", 1)
1140 self.assertEqual(e.name, "a")
1141 self.assertEqual(e.value, 1)
1142
1143 self.assertRaises(TypeError, TypeEnumerator, "a", None)
1144 self.assertRaises(TypeError, TypeEnumerator, None, 1)
1145
1146 def test_repr(self):
1147 e = TypeEnumerator("a", 1)
1148 self.assertEqual(repr(e), "TypeEnumerator('a', 1)")
1149
1150 def test_sequence(self):
1151 e = TypeEnumerator("a", 1)
1152 name, value = e
1153 self.assertEqual(name, "a")
1154 self.assertEqual(value, 1)
1155 self.assertEqual(list(e), ["a", 1])
1156
1157 def test_cmp(self):
1158 self.assertEqual(TypeEnumerator("a", 1), TypeEnumerator(name="a", value=1))
1159 self.assertNotEqual(TypeEnumerator("a", 1), TypeEnumerator("a", 2))
1160 self.assertNotEqual(TypeEnumerator("b", 1), TypeEnumerator("a", 1))
1161
1162
1163 class TestTypeMember(MockProgramTestCase):
1164 def test_init(self):
1165 m = TypeMember(self.prog.void_type())
1166 self.assertIdentical(m.object, Object(self.prog, self.prog.void_type()))
1167 self.assertIdentical(m.type, self.prog.void_type())
1168 self.assertIsNone(m.name)
1169 self.assertEqual(m.bit_offset, 0)
1170 self.assertEqual(m.offset, 0)
1171 self.assertIsNone(m.bit_field_size)
1172
1173 m = TypeMember(Object(self.prog, self.prog.void_type()), "foo")
1174 self.assertIdentical(m.object, Object(self.prog, self.prog.void_type()))
1175 self.assertIdentical(m.type, self.prog.void_type())
1176 self.assertEqual(m.name, "foo")
1177 self.assertEqual(m.bit_offset, 0)
1178 self.assertEqual(m.offset, 0)
1179 self.assertIsNone(m.bit_field_size)
1180
1181 m = TypeMember(self.prog.void_type(), "foo", 8)
1182 self.assertIdentical(m.object, Object(self.prog, self.prog.void_type()))
1183 self.assertIdentical(m.type, self.prog.void_type())
1184 self.assertEqual(m.name, "foo")
1185 self.assertEqual(m.bit_offset, 8)
1186 self.assertEqual(m.offset, 1)
1187 self.assertIsNone(m.bit_field_size)
1188
1189 self.assertRaises(TypeError, TypeMember, None)
1190 self.assertRaises(TypeError, TypeMember, self.prog.void_type(), 1)
1191 self.assertRaises(TypeError, TypeMember, self.prog.void_type(), "foo", None)
1192
1193 def test_callable(self):
1194 m = TypeMember(self.prog.void_type)
1195 self.assertIdentical(m.object, Object(self.prog, self.prog.void_type()))
1196 self.assertIdentical(m.type, self.prog.void_type())
1197
1198 m = TypeMember(lambda: Object(self.prog, self.prog.int_type("int", 4, True)))
1199 self.assertIdentical(
1200 m.object, Object(self.prog, self.prog.int_type("int", 4, True))
1201 )
1202 self.assertIdentical(m.type, self.prog.int_type("int", 4, True))
1203
1204 m = TypeMember(lambda: None)
1205 self.assertRaises(TypeError, getattr, m, "type")
1206
1207 def test_repr(self):
1208 m = TypeMember(self.prog.void_type, name="foo")
1209 self.assertEqual(
1210 repr(m), "TypeMember(prog.type('void'), name='foo', bit_offset=0)"
1211 )
1212
1213 m = TypeMember(self.prog.void_type)
1214 self.assertEqual(repr(m), "TypeMember(prog.type('void'), bit_offset=0)")
1215
1216 m = TypeMember(
1217 Object(self.prog, self.prog.int_type("int", 4, True), bit_field_size=1)
1218 )
1219 self.assertEqual(
1220 repr(m), "TypeMember(Object(prog, 'int', bit_field_size=1), bit_offset=0)"
1221 )
1222
1223 m = TypeMember(lambda: None)
1224 self.assertRaises(TypeError, repr, m)
1225
1226
1227 class TestTypeParameter(MockProgramTestCase):
1228 def test_init(self):
1229 p = TypeParameter(self.prog.void_type())
1230 self.assertIdentical(
1231 p.default_argument, Object(self.prog, self.prog.void_type())
1232 )
1233 self.assertIdentical(p.type, self.prog.void_type())
1234 self.assertIsNone(p.name)
1235
1236 p = TypeParameter(
1237 Object(self.prog, self.prog.int_type("int", 4, True), 5), "foo"
1238 )
1239 self.assertIdentical(
1240 p.default_argument, Object(self.prog, self.prog.int_type("int", 4, True), 5)
1241 )
1242 self.assertIdentical(p.type, self.prog.int_type("int", 4, True))
1243 self.assertEqual(p.name, "foo")
1244
1245 self.assertRaises(TypeError, TypeParameter, None)
1246 self.assertRaises(TypeError, TypeParameter, self.prog.void_type(), 1)
1247
1248 def test_callable(self):
1249 p = TypeParameter(self.prog.void_type)
1250 self.assertIdentical(
1251 p.default_argument, Object(self.prog, self.prog.void_type())
1252 )
1253 self.assertIdentical(p.type, self.prog.void_type())
1254
1255 p = TypeParameter(lambda: Object(self.prog, self.prog.int_type("int", 4, True)))
1256 self.assertIdentical(
1257 p.default_argument, Object(self.prog, self.prog.int_type("int", 4, True))
1258 )
1259 self.assertIdentical(p.type, self.prog.int_type("int", 4, True))
1260
1261 p = TypeParameter(lambda: None)
1262 self.assertRaises(TypeError, getattr, p, "type")
1263
1264 def test_repr(self):
1265 p = TypeParameter(self.prog.void_type, name="foo")
1266 self.assertEqual(repr(p), "TypeParameter(prog.type('void'), name='foo')")
1267
1268 p = TypeParameter(self.prog.void_type)
1269 self.assertEqual(repr(p), "TypeParameter(prog.type('void'))")
1270
1271 p = TypeParameter(lambda: None)
1272 self.assertRaises(TypeError, repr, p)
1273
1274
1275 class TestTypeTemplateParameter(MockProgramTestCase):
1276 def test_init(self):
1277 p = TypeTemplateParameter(self.prog.void_type())
1278 self.assertIdentical(p.argument, self.prog.void_type())
1279 self.assertIsNone(p.name)
1280 self.assertFalse(p.is_default)
1281
1282 p = TypeTemplateParameter(
1283 Object(self.prog, self.prog.int_type("int", 4, True), 5), "foo", True
1284 )
1285 self.assertIdentical(
1286 p.argument, Object(self.prog, self.prog.int_type("int", 4, True), 5)
1287 )
1288 self.assertEqual(p.name, "foo")
1289 self.assertTrue(p.is_default)
1290
1291 self.assertRaises(TypeError, TypeTemplateParameter, None)
1292 self.assertRaisesRegex(
1293 ValueError,
1294 "must not be absent Object",
1295 TypeTemplateParameter,
1296 Object(self.prog, "int"),
1297 )
1298 self.assertRaises(TypeError, TypeTemplateParameter, self.prog.void_type(), 1)
1299 self.assertRaises(
1300 TypeError, TypeTemplateParameter, self.prog.void_type(), None, None
1301 )
1302
1303 def test_callable(self):
1304 p = TypeTemplateParameter(self.prog.void_type)
1305 self.assertIdentical(p.argument, self.prog.void_type())
1306
1307 p = TypeTemplateParameter(
1308 lambda: Object(self.prog, self.prog.int_type("int", 4, True), 5)
1309 )
1310 self.assertIdentical(
1311 p.argument, Object(self.prog, self.prog.int_type("int", 4, True), 5)
1312 )
1313
1314 p = TypeTemplateParameter(lambda: None)
1315 self.assertRaises(TypeError, getattr, p, "argument")
1316 p = TypeTemplateParameter(lambda: Object(self.prog, "int"))
1317 self.assertRaisesRegex(
1318 ValueError, "must not return absent Object", getattr, p, "argument"
1319 )
1320
1321 def test_repr(self):
1322 p = TypeTemplateParameter(self.prog.void_type, name="foo", is_default=True)
1323 self.assertEqual(
1324 repr(p),
1325 "TypeTemplateParameter(prog.type('void'), name='foo', is_default=True)",
1326 )
1327
1328 p = TypeTemplateParameter(self.prog.void_type)
1329 self.assertEqual(repr(p), "TypeTemplateParameter(prog.type('void'))")
1330
1331 p = TypeTemplateParameter(lambda: None)
1332 self.assertRaises(TypeError, repr, p)
1333
1334
1335 class TestAlignof(TestCase):
1336 def setUp(self):
1337 self.prog = Program(Platform(Architecture.X86_64))
1338
1339 def test_scalar(self):
1340 self.assertEqual(alignof(self.prog.int_type("char", 1, True)), 1)
1341 self.assertEqual(alignof(self.prog.int_type("short", 2, True)), 2)
1342 self.assertEqual(alignof(self.prog.int_type("int", 4, True)), 4)
1343 self.assertEqual(alignof(self.prog.int_type("long long", 8, True)), 8)
1344 self.assertEqual(alignof(self.prog.int_type("__int128", 16, True)), 16)
1345 self.assertEqual(alignof(self.prog.bool_type("_Bool", 1)), 1)
1346 self.assertEqual(alignof(self.prog.float_type("float", 4)), 4)
1347 self.assertEqual(alignof(self.prog.float_type("double", 8)), 8)
1348 self.assertEqual(alignof(self.prog.float_type("long double", 16)), 16)
1349 self.assertEqual(alignof(self.prog.pointer_type(self.prog.void_type())), 8)
1350
1351 def test_empty_struct(self):
1352 self.assertEqual(alignof(self.prog.struct_type(None, 0, ())), 1)
1353
1354 def test_struct(self):
1355 self.assertEqual(
1356 alignof(
1357 self.prog.struct_type(
1358 None,
1359 16,
1360 (
1361 TypeMember(self.prog.int_type("int", 4, True), "i", 0),
1362 TypeMember(self.prog.int_type("long long", 8, True), "ll", 64),
1363 ),
1364 )
1365 ),
1366 8,
1367 )
1368
1369 def test_union(self):
1370 self.assertEqual(
1371 alignof(
1372 self.prog.struct_type(
1373 None,
1374 8,
1375 (
1376 TypeMember(self.prog.int_type("int", 4, True), "i"),
1377 TypeMember(self.prog.int_type("long long", 8, True), "ll"),
1378 ),
1379 )
1380 ),
1381 8,
1382 )
1383
1384 def test_enum(self):
1385 self.assertEqual(
1386 alignof(self.prog.enum_type(None, self.prog.int_type("int", 4, True), ())),
1387 4,
1388 )
1389
1390 def test_typedef(self):
1391 self.assertEqual(
1392 alignof(self.prog.typedef_type("INT", self.prog.int_type("int", 4, True))),
1393 4,
1394 )
1395
1396 def test_array(self):
1397 self.assertEqual(
1398 alignof(self.prog.array_type(self.prog.int_type("int", 4, True), 8)), 4
1399 )
1400
1401 def test_incomplete_type(self):
1402 self.assertRaises(TypeError, alignof, self.prog.void_type())
1403
1404 def test_cycle(self):
1405 type = self.prog.struct_type(None, 8, (TypeMember(lambda: type, "foo"),))
1406 self.assertRaises(RecursionError, alignof, type)
1407
1408 def test_default_prog(self):
1409 self.assertRaises(NoDefaultProgramError, alignof, "int")
1410 with with_default_prog(self.prog):
1411 self.assertEqual(alignof("int"), 4)
1412 self.assertRaises(LookupError, alignof, "struct foo")