Debian Codegraph @

Lib/test/test_ctypes/test_structunion.py

raw
1 """Common tests for ctypes.Structure and ctypes.Union"""
2
3 import unittest
4 import sys
5 from ctypes import (Structure, Union, POINTER, sizeof, alignment,
6 c_char, c_byte, c_ubyte,
7 c_short, c_ushort, c_int, c_uint,
8 c_long, c_ulong, c_longlong, c_ulonglong, c_float, c_double,
9 c_int8, c_int16, c_int32)
10 from ._support import (_CData, PyCStructType, UnionType,
11 Py_TPFLAGS_DISALLOW_INSTANTIATION,
12 Py_TPFLAGS_IMMUTABLETYPE)
13 from struct import calcsize
14 import contextlib
15 from test.support import MS_WINDOWS
16
17
18 class StructUnionTestBase:
19 formats = {"c": c_char,
20 "b": c_byte,
21 "B": c_ubyte,
22 "h": c_short,
23 "H": c_ushort,
24 "i": c_int,
25 "I": c_uint,
26 "l": c_long,
27 "L": c_ulong,
28 "q": c_longlong,
29 "Q": c_ulonglong,
30 "f": c_float,
31 "d": c_double,
32 }
33
34 def test_subclass(self):
35 class X(self.cls):
36 _fields_ = [("a", c_int)]
37
38 class Y(X):
39 _fields_ = [("b", c_int)]
40
41 class Z(X):
42 pass
43
44 self.assertEqual(sizeof(X), sizeof(c_int))
45 self.check_sizeof(Y,
46 struct_size=sizeof(c_int)*2,
47 union_size=sizeof(c_int))
48 self.assertEqual(sizeof(Z), sizeof(c_int))
49 self.assertEqual(X._fields_, [("a", c_int)])
50 self.assertEqual(Y._fields_, [("b", c_int)])
51 self.assertEqual(Z._fields_, [("a", c_int)])
52
53 def test_subclass_delayed(self):
54 class X(self.cls):
55 pass
56 self.assertEqual(sizeof(X), 0)
57 X._fields_ = [("a", c_int)]
58
59 class Y(X):
60 pass
61 self.assertEqual(sizeof(Y), sizeof(X))
62 Y._fields_ = [("b", c_int)]
63
64 class Z(X):
65 pass
66
67 self.assertEqual(sizeof(X), sizeof(c_int))
68 self.check_sizeof(Y,
69 struct_size=sizeof(c_int)*2,
70 union_size=sizeof(c_int))
71 self.assertEqual(sizeof(Z), sizeof(c_int))
72 self.assertEqual(X._fields_, [("a", c_int)])
73 self.assertEqual(Y._fields_, [("b", c_int)])
74 self.assertEqual(Z._fields_, [("a", c_int)])
75
76 def test_inheritance_hierarchy(self):
77 self.assertEqual(self.cls.mro(), [self.cls, _CData, object])
78 self.assertEqual(type(self.metacls), type)
79
80 def test_type_flags(self):
81 for cls in self.cls, self.metacls:
82 with self.subTest(cls=cls):
83 self.assertTrue(cls.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
84 self.assertFalse(cls.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
85
86 def test_metaclass_details(self):
87 # Abstract classes (whose metaclass __init__ was not called) can't be
88 # instantiated directly
89 NewClass = self.metacls.__new__(self.metacls, 'NewClass',
90 (self.cls,), {})
91 for cls in self.cls, NewClass:
92 with self.subTest(cls=cls):
93 with self.assertRaisesRegex(TypeError, "abstract class"):
94 obj = cls()
95
96 # Cannot call the metaclass __init__ more than once
97 class T(self.cls):
98 _fields_ = [("x", c_char),
99 ("y", c_char)]
100 with self.assertRaisesRegex(SystemError, "already initialized"):
101 self.metacls.__init__(T, 'ptr', (), {})
102
103 def test_alignment(self):
104 class X(self.cls):
105 _fields_ = [("x", c_char * 3)]
106 self.assertEqual(alignment(X), calcsize("s"))
107 self.assertEqual(sizeof(X), calcsize("3s"))
108
109 class Y(self.cls):
110 _fields_ = [("x", c_char * 3),
111 ("y", c_int)]
112 self.assertEqual(alignment(Y), alignment(c_int))
113 self.check_sizeof(Y,
114 struct_size=calcsize("3s i"),
115 union_size=max(calcsize("3s"), calcsize("i")))
116
117 class SI(self.cls):
118 _fields_ = [("a", X),
119 ("b", Y)]
120 self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
121 self.check_sizeof(SI,
122 struct_size=calcsize("3s0i 3si 0i"),
123 union_size=max(calcsize("3s"), calcsize("i")))
124
125 class IS(self.cls):
126 _fields_ = [("b", Y),
127 ("a", X)]
128
129 self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
130 self.check_sizeof(IS,
131 struct_size=calcsize("3si 3s 0i"),
132 union_size=max(calcsize("3s"), calcsize("i")))
133
134 class XX(self.cls):
135 _fields_ = [("a", X),
136 ("b", X)]
137 self.assertEqual(alignment(XX), alignment(X))
138 self.check_sizeof(XX,
139 struct_size=calcsize("3s 3s 0s"),
140 union_size=calcsize("3s"))
141
142 def test_empty(self):
143 # I had problems with these
144 #
145 # Although these are pathological cases: Empty Structures!
146 class X(self.cls):
147 _fields_ = []
148
149 # Is this really the correct alignment, or should it be 0?
150 self.assertTrue(alignment(X) == 1)
151 self.assertTrue(sizeof(X) == 0)
152
153 class XX(self.cls):
154 _fields_ = [("a", X),
155 ("b", X)]
156
157 self.assertEqual(alignment(XX), 1)
158 self.assertEqual(sizeof(XX), 0)
159
160 def test_fields(self):
161 # test the offset and size attributes of Structure/Union fields.
162 class X(self.cls):
163 _fields_ = [("x", c_int),
164 ("y", c_char)]
165
166 self.assertEqual(X.x.offset, 0)
167 self.assertEqual(X.x.size, sizeof(c_int))
168
169 if self.cls == Structure:
170 self.assertEqual(X.y.offset, sizeof(c_int))
171 else:
172 self.assertEqual(X.y.offset, 0)
173 self.assertEqual(X.y.size, sizeof(c_char))
174
175 # readonly
176 self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
177 self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
178
179 # XXX Should we check nested data types also?
180 # offset is always relative to the class...
181
182 def test_field_descriptor_attributes(self):
183 """Test information provided by the descriptors"""
184 class Inner(Structure):
185 _fields_ = [
186 ("a", c_int16),
187 ("b", c_int8, 1),
188 ("c", c_int8, 2),
189 ]
190 class X(self.cls):
191 _fields_ = [
192 ("x", c_int32),
193 ("y", c_int16, 1),
194 ("_", Inner),
195 ]
196 _anonymous_ = ["_"]
197
198 field_names = "xy_abc"
199
200 # name
201
202 for name in field_names:
203 with self.subTest(name=name):
204 self.assertEqual(getattr(X, name).name, name)
205
206 # type
207
208 expected_types = dict(
209 x=c_int32,
210 y=c_int16,
211 _=Inner,
212 a=c_int16,
213 b=c_int8,
214 c=c_int8,
215 )
216 assert set(expected_types) == set(field_names)
217 for name, tp in expected_types.items():
218 with self.subTest(name=name):
219 self.assertEqual(getattr(X, name).type, tp)
220 self.assertEqual(getattr(X, name).byte_size, sizeof(tp))
221
222 # offset, byte_offset
223
224 expected_offsets = dict(
225 x=(0, 0),
226 y=(0, 4),
227 _=(0, 6),
228 a=(0, 6),
229 b=(2, 8),
230 c=(2, 8),
231 )
232 assert set(expected_offsets) == set(field_names)
233 for name, (union_offset, struct_offset) in expected_offsets.items():
234 with self.subTest(name=name):
235 self.assertEqual(getattr(X, name).offset,
236 getattr(X, name).byte_offset)
237 if self.cls == Structure:
238 self.assertEqual(getattr(X, name).offset, struct_offset)
239 else:
240 self.assertEqual(getattr(X, name).offset, union_offset)
241
242 # is_bitfield, bit_size, bit_offset
243 # size
244
245 little_endian = (sys.byteorder == 'little')
246 expected_bitfield_info = dict(
247 # (bit_size, bit_offset)
248 b=(1, 0 if little_endian else 7),
249 c=(2, 1 if little_endian else 5),
250 y=(1, 0 if little_endian else 15),
251 )
252 for name in field_names:
253 with self.subTest(name=name):
254 if info := expected_bitfield_info.get(name):
255 self.assertEqual(getattr(X, name).is_bitfield, True)
256 expected_bit_size, expected_bit_offset = info
257 self.assertEqual(getattr(X, name).bit_size,
258 expected_bit_size)
259 self.assertEqual(getattr(X, name).bit_offset,
260 expected_bit_offset)
261 self.assertEqual(getattr(X, name).size,
262 (expected_bit_size << 16)
263 | expected_bit_offset)
264 else:
265 self.assertEqual(getattr(X, name).is_bitfield, False)
266 type_size = sizeof(expected_types[name])
267 self.assertEqual(getattr(X, name).bit_size, type_size * 8)
268 self.assertEqual(getattr(X, name).bit_offset, 0)
269 self.assertEqual(getattr(X, name).size, type_size)
270
271 # is_anonymous
272
273 for name in field_names:
274 with self.subTest(name=name):
275 self.assertEqual(getattr(X, name).is_anonymous, (name == '_'))
276
277
278 def test_invalid_field_types(self):
279 class POINT(self.cls):
280 pass
281 self.assertRaises(TypeError, setattr, POINT, "_fields_", [("x", 1), ("y", 2)])
282
283 def test_invalid_name(self):
284 # field name must be string
285 for name in b"x", 3, None:
286 with self.subTest(name=name):
287 with self.assertRaises(TypeError):
288 class S(self.cls):
289 _fields_ = [(name, c_int)]
290
291 def test_str_name(self):
292 class WeirdString(str):
293 def __str__(self):
294 return "unwanted value"
295 class S(self.cls):
296 _fields_ = [(WeirdString("f"), c_int)]
297 self.assertEqual(S.f.name, "f")
298
299 def test_intarray_fields(self):
300 class SomeInts(self.cls):
301 _fields_ = [("a", c_int * 4)]
302
303 # can use tuple to initialize array (but not list!)
304 self.assertEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
305 self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
306 self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
307 self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
308 self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
309 self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
310 self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
311 self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
312 # too long
313 # XXX Should raise ValueError?, not RuntimeError
314 self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
315
316 def test_huge_field_name(self):
317 # issue12881: segfault with large structure field names
318 def create_class(length):
319 class S(self.cls):
320 _fields_ = [('x' * length, c_int)]
321
322 for length in [10 ** i for i in range(0, 8)]:
323 try:
324 create_class(length)
325 except MemoryError:
326 # MemoryErrors are OK, we just don't want to segfault
327 pass
328
329 def test_abstract_class(self):
330 class X(self.cls):
331 _abstract_ = "something"
332 with self.assertRaisesRegex(TypeError, r"^abstract class$"):
333 X()
334
335 def test_methods(self):
336 self.assertIn("in_dll", dir(type(self.cls)))
337 self.assertIn("from_address", dir(type(self.cls)))
338 self.assertIn("in_dll", dir(type(self.cls)))
339
340 def test_pack_layout_switch(self):
341 # Setting _pack_ implicitly sets default layout to MSVC;
342 # this is deprecated on non-Windows platforms.
343 if MS_WINDOWS:
344 warn_context = contextlib.nullcontext()
345 else:
346 warn_context = self.assertWarns(DeprecationWarning)
347 with warn_context:
348 class X(self.cls):
349 _pack_ = 1
350 # _layout_ missing
351 _fields_ = [('a', c_int8, 1), ('b', c_int16, 2)]
352
353 # Check MSVC layout (bitfields of different types aren't combined)
354 self.check_sizeof(X, struct_size=3, union_size=2)
355
356
357 class StructureTestCase(unittest.TestCase, StructUnionTestBase):
358 cls = Structure
359 metacls = PyCStructType
360
361 def test_metaclass_name(self):
362 self.assertEqual(self.metacls.__name__, "PyCStructType")
363
364 def check_sizeof(self, cls, *, struct_size, union_size):
365 self.assertEqual(sizeof(cls), struct_size)
366
367 def test_simple_structs(self):
368 for code, tp in self.formats.items():
369 class X(Structure):
370 _fields_ = [("x", c_char),
371 ("y", tp)]
372 self.assertEqual((sizeof(X), code),
373 (calcsize("c%c0%c" % (code, code)), code))
374
375
376 class UnionTestCase(unittest.TestCase, StructUnionTestBase):
377 cls = Union
378 metacls = UnionType
379
380 def test_metaclass_name(self):
381 self.assertEqual(self.metacls.__name__, "UnionType")
382
383 def check_sizeof(self, cls, *, struct_size, union_size):
384 self.assertEqual(sizeof(cls), union_size)
385
386 def test_simple_unions(self):
387 for code, tp in self.formats.items():
388 class X(Union):
389 _fields_ = [("x", c_char),
390 ("y", tp)]
391 self.assertEqual((sizeof(X), code),
392 (calcsize("%c" % (code)), code))
393
394
395 class PointerMemberTestBase:
396 def test(self):
397 # a Structure/Union with a POINTER field
398 class S(self.cls):
399 _fields_ = [("array", POINTER(c_int))]
400
401 s = S()
402 # We can assign arrays of the correct type
403 s.array = (c_int * 3)(1, 2, 3)
404 items = [s.array[i] for i in range(3)]
405 self.assertEqual(items, [1, 2, 3])
406
407 s.array[0] = 42
408
409 items = [s.array[i] for i in range(3)]
410 self.assertEqual(items, [42, 2, 3])
411
412 s.array[0] = 1
413
414 items = [s.array[i] for i in range(3)]
415 self.assertEqual(items, [1, 2, 3])
416
417 class PointerMemberTestCase_Struct(unittest.TestCase, PointerMemberTestBase):
418 cls = Structure
419
420 def test_none_to_pointer_fields(self):
421 class S(self.cls):
422 _fields_ = [("x", c_int),
423 ("p", POINTER(c_int))]
424
425 s = S()
426 s.x = 12345678
427 s.p = None
428 self.assertEqual(s.x, 12345678)
429
430 class PointerMemberTestCase_Union(unittest.TestCase, PointerMemberTestBase):
431 cls = Union
432
433 def test_none_to_pointer_fields(self):
434 class S(self.cls):
435 _fields_ = [("x", c_int),
436 ("p", POINTER(c_int))]
437
438 s = S()
439 s.x = 12345678
440 s.p = None
441 self.assertFalse(s.p) # NULL pointers are falsy
442
443
444 class TestRecursiveBase:
445 def test_contains_itself(self):
446 class Recursive(self.cls):
447 pass
448
449 try:
450 Recursive._fields_ = [("next", Recursive)]
451 except AttributeError as details:
452 self.assertIn("Structure or union cannot contain itself",
453 str(details))
454 else:
455 self.fail("Structure or union cannot contain itself")
456
457
458 def test_vice_versa(self):
459 class First(self.cls):
460 pass
461 class Second(self.cls):
462 pass
463
464 First._fields_ = [("second", Second)]
465
466 try:
467 Second._fields_ = [("first", First)]
468 except AttributeError as details:
469 self.assertIn("_fields_ is final", str(details))
470 else:
471 self.fail("AttributeError not raised")
472
473 class TestRecursiveStructure(unittest.TestCase, TestRecursiveBase):
474 cls = Structure
475
476 class TestRecursiveUnion(unittest.TestCase, TestRecursiveBase):
477 cls = Union