Debian Codegraph @

Lib/test/test_ctypes/test_bitfields.py

raw
1 import os
2 import sys
3 import unittest
4 from ctypes import (CDLL, Structure, sizeof, POINTER, byref, alignment,
5 LittleEndianStructure, BigEndianStructure,
6 c_byte, c_ubyte, c_char, c_char_p, c_void_p, c_wchar,
7 c_uint8, c_uint16, c_uint32, c_uint64,
8 c_short, c_ushort, c_int, c_uint, c_long, c_ulong,
9 c_longlong, c_ulonglong,
10 Union)
11 from test import support
12 from test.support import import_helper
13 from ._support import StructCheckMixin
14 _ctypes_test = import_helper.import_module("_ctypes_test")
15
16
17 TEST_FIELDS = (
18 ("A", c_int, 1),
19 ("B", c_int, 2),
20 ("C", c_int, 3),
21 ("D", c_int, 4),
22 ("E", c_int, 5),
23 ("F", c_int, 6),
24 ("G", c_int, 7),
25 ("H", c_int, 8),
26 ("I", c_int, 9),
27
28 ("M", c_short, 1),
29 ("N", c_short, 2),
30 ("O", c_short, 3),
31 ("P", c_short, 4),
32 ("Q", c_short, 5),
33 ("R", c_short, 6),
34 ("S", c_short, 7),
35 )
36
37
38 class BITS(Structure):
39 _fields_ = TEST_FIELDS
40
41 func = CDLL(_ctypes_test.__file__).unpack_bitfields
42 func.argtypes = POINTER(BITS), c_char
43
44
45 class BITS_msvc(Structure):
46 _layout_ = "ms"
47 _fields_ = TEST_FIELDS
48
49
50 class BITS_gcc(Structure):
51 _layout_ = "gcc-sysv"
52 _fields_ = TEST_FIELDS
53
54
55 try:
56 func_msvc = CDLL(_ctypes_test.__file__).unpack_bitfields_msvc
57 except AttributeError as err:
58 # The MSVC struct must be available on Windows; it's optional elsewhere
59 if support.MS_WINDOWS:
60 raise err
61 func_msvc = None
62 else:
63 func_msvc.argtypes = POINTER(BITS_msvc), c_char
64
65
66 class C_Test(unittest.TestCase):
67
68 def test_ints(self):
69 for i in range(512):
70 for name in "ABCDEFGHI":
71 with self.subTest(i=i, name=name):
72 b = BITS()
73 setattr(b, name, i)
74 self.assertEqual(
75 getattr(b, name),
76 func(byref(b), (name.encode('ascii'))))
77
78 def test_shorts(self):
79 b = BITS()
80 name = "M"
81 # See Modules/_ctypes/_ctypes_test.c for where the magic 999 comes from.
82 if func(byref(b), name.encode('ascii')) == 999:
83 # unpack_bitfields and unpack_bitfields_msvc in
84 # Modules/_ctypes/_ctypes_test.c return 999 to indicate
85 # an invalid name. 'M' is only valid, if signed short bitfields
86 # are supported by the C compiler.
87 self.skipTest("Compiler does not support signed short bitfields")
88 for i in range(256):
89 for name in "MNOPQRS":
90 with self.subTest(i=i, name=name):
91 b = BITS()
92 setattr(b, name, i)
93 self.assertEqual(
94 getattr(b, name),
95 func(byref(b), (name.encode('ascii'))))
96
97 @unittest.skipUnless(func_msvc, "need MSVC or __attribute__((ms_struct))")
98 def test_shorts_msvc_mode(self):
99 b = BITS_msvc()
100 name = "M"
101 # See Modules/_ctypes/_ctypes_test.c for where the magic 999 comes from.
102 if func_msvc(byref(b), name.encode('ascii')) == 999:
103 # unpack_bitfields and unpack_bitfields_msvc in
104 # Modules/_ctypes/_ctypes_test.c return 999 to indicate
105 # an invalid name. 'M' is only valid, if signed short bitfields
106 # are supported by the C compiler.
107 self.skipTest("Compiler does not support signed short bitfields")
108 for i in range(256):
109 for name in "MNOPQRS":
110 with self.subTest(i=i, name=name):
111 b = BITS_msvc()
112 setattr(b, name, i)
113 self.assertEqual(
114 getattr(b, name),
115 func_msvc(byref(b), name.encode('ascii')))
116
117
118 signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong)
119 unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
120 int_types = unsigned_int_types + signed_int_types
121
122 class BitFieldTest(unittest.TestCase, StructCheckMixin):
123
124 def test_generic_checks(self):
125 self.check_struct(BITS)
126 self.check_struct(BITS_msvc)
127 self.check_struct(BITS_gcc)
128
129 def test_longlong(self):
130 class X(Structure):
131 _fields_ = [("a", c_longlong, 1),
132 ("b", c_longlong, 62),
133 ("c", c_longlong, 1)]
134 self.check_struct(X)
135
136 self.assertEqual(sizeof(X), sizeof(c_longlong))
137 x = X()
138 x.a, x.b, x.c = -1, 7, -1
139 self.assertEqual((x.a, x.b, x.c), (-1, 7, -1))
140
141 def test_ulonglong(self):
142 class X(Structure):
143 _fields_ = [("a", c_ulonglong, 1),
144 ("b", c_ulonglong, 62),
145 ("c", c_ulonglong, 1)]
146 self.check_struct(X)
147
148 self.assertEqual(sizeof(X), sizeof(c_longlong))
149 x = X()
150 self.assertEqual((x.a, x.b, x.c), (0, 0, 0))
151 x.a, x.b, x.c = 7, 7, 7
152 self.assertEqual((x.a, x.b, x.c), (1, 7, 1))
153
154 def test_signed(self):
155 for c_typ in signed_int_types:
156 with self.subTest(c_typ):
157 if sizeof(c_typ) != alignment(c_typ):
158 self.skipTest('assumes size=alignment')
159 class X(Structure):
160 _fields_ = [("dummy", c_typ),
161 ("a", c_typ, 3),
162 ("b", c_typ, 3),
163 ("c", c_typ, 1)]
164 self.check_struct(X)
165 self.assertEqual(sizeof(X), sizeof(c_typ)*2)
166
167 x = X()
168 self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
169 x.a = -1
170 self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0))
171 x.a, x.b = 0, -1
172 self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0))
173
174
175 def test_unsigned(self):
176 for c_typ in unsigned_int_types:
177 with self.subTest(c_typ):
178 if sizeof(c_typ) != alignment(c_typ):
179 self.skipTest('assumes size=alignment')
180 class X(Structure):
181 _fields_ = [("a", c_typ, 3),
182 ("b", c_typ, 3),
183 ("c", c_typ, 1)]
184 self.check_struct(X)
185 self.assertEqual(sizeof(X), sizeof(c_typ))
186
187 x = X()
188 self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
189 x.a = -1
190 self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0))
191 x.a, x.b = 0, -1
192 self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0))
193
194 def fail_fields(self, *fields):
195 for layout in "ms", "gcc-sysv":
196 with self.subTest(layout=layout):
197 return self.get_except(type(Structure), "X", (),
198 {"_fields_": fields, "layout": layout})
199
200 def test_nonint_types(self):
201 # bit fields are not allowed on non-integer types.
202 result = self.fail_fields(("a", c_char_p, 1))
203 self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char_p'))
204
205 result = self.fail_fields(("a", c_void_p, 1))
206 self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_void_p'))
207
208 if c_int != c_long:
209 result = self.fail_fields(("a", POINTER(c_int), 1))
210 self.assertEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int'))
211
212 result = self.fail_fields(("a", c_char, 1))
213 self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char'))
214
215 class Empty(Structure):
216 _fields_ = []
217 self.check_struct(Empty)
218
219 result = self.fail_fields(("a", Empty, 1))
220 self.assertEqual(result, (ValueError, "number of bits invalid for bit field 'a'"))
221
222 class Dummy(Structure):
223 _fields_ = [("x", c_int)]
224 self.check_struct(Dummy)
225
226 result = self.fail_fields(("a", Dummy, 1))
227 self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy'))
228
229 def test_c_wchar(self):
230 result = self.fail_fields(("a", c_wchar, 1))
231 self.assertEqual(result,
232 (TypeError, 'bit fields not allowed for type c_wchar'))
233
234 def test_single_bitfield_size(self):
235 for c_typ in int_types:
236 with self.subTest(c_typ):
237 if sizeof(c_typ) != alignment(c_typ):
238 self.skipTest('assumes size=alignment')
239 result = self.fail_fields(("a", c_typ, -1))
240 self.assertEqual(result, (ValueError,
241 "number of bits invalid for bit field 'a'"))
242
243 result = self.fail_fields(("a", c_typ, 0))
244 self.assertEqual(result, (ValueError,
245 "number of bits invalid for bit field 'a'"))
246
247 class X(Structure):
248 _fields_ = [("a", c_typ, 1)]
249 self.check_struct(X)
250 self.assertEqual(sizeof(X), sizeof(c_typ))
251
252 class X(Structure):
253 _fields_ = [("a", c_typ, sizeof(c_typ)*8)]
254 self.check_struct(X)
255 self.assertEqual(sizeof(X), sizeof(c_typ))
256
257 result = self.fail_fields(("a", c_typ, sizeof(c_typ)*8 + 1))
258 self.assertEqual(result, (ValueError,
259 "number of bits invalid for bit field 'a'"))
260
261 def test_multi_bitfields_size(self):
262 class X(Structure):
263 _fields_ = [("a", c_short, 1),
264 ("b", c_short, 14),
265 ("c", c_short, 1)]
266 self.check_struct(X)
267 self.assertEqual(sizeof(X), sizeof(c_short))
268
269 class X(Structure):
270 _fields_ = [("a", c_short, 1),
271 ("a1", c_short),
272 ("b", c_short, 14),
273 ("c", c_short, 1)]
274 self.check_struct(X)
275 self.assertEqual(sizeof(X), sizeof(c_short)*3)
276 self.assertEqual(X.a.offset, 0)
277 self.assertEqual(X.a1.offset, sizeof(c_short))
278 self.assertEqual(X.b.offset, sizeof(c_short)*2)
279 self.assertEqual(X.c.offset, sizeof(c_short)*2)
280
281 class X(Structure):
282 _fields_ = [("a", c_short, 3),
283 ("b", c_short, 14),
284 ("c", c_short, 14)]
285 self.check_struct(X)
286 self.assertEqual(sizeof(X), sizeof(c_short)*3)
287 self.assertEqual(X.a.offset, sizeof(c_short)*0)
288 self.assertEqual(X.b.offset, sizeof(c_short)*1)
289 self.assertEqual(X.c.offset, sizeof(c_short)*2)
290
291 def get_except(self, func, *args, **kw):
292 try:
293 func(*args, **kw)
294 except Exception as detail:
295 return detail.__class__, str(detail)
296
297 def test_mixed_1(self):
298 class X(Structure):
299 _fields_ = [("a", c_byte, 4),
300 ("b", c_int, 4)]
301 self.check_struct(X)
302 if os.name == "nt":
303 self.assertEqual(sizeof(X), sizeof(c_int)*2)
304 else:
305 self.assertEqual(sizeof(X), sizeof(c_int))
306
307 def test_mixed_2(self):
308 class X(Structure):
309 _fields_ = [("a", c_byte, 4),
310 ("b", c_int, 32)]
311 self.check_struct(X)
312 self.assertEqual(sizeof(X), alignment(c_int)+sizeof(c_int))
313
314 def test_mixed_3(self):
315 class X(Structure):
316 _fields_ = [("a", c_byte, 4),
317 ("b", c_ubyte, 4)]
318 self.check_struct(X)
319 self.assertEqual(sizeof(X), sizeof(c_byte))
320
321 def test_mixed_4(self):
322 class X(Structure):
323 _fields_ = [("a", c_short, 4),
324 ("b", c_short, 4),
325 ("c", c_int, 24),
326 ("d", c_short, 4),
327 ("e", c_short, 4),
328 ("f", c_int, 24)]
329 self.check_struct(X)
330 # MSVC does NOT combine c_short and c_int into one field, GCC
331 # does (unless GCC is run with '-mms-bitfields' which
332 # produces code compatible with MSVC).
333 if os.name == "nt":
334 self.assertEqual(sizeof(X), sizeof(c_int) * 4)
335 else:
336 self.assertEqual(sizeof(X), sizeof(c_int) * 2)
337
338 def test_mixed_5(self):
339 class X(Structure):
340 _fields_ = [
341 ('A', c_uint, 1),
342 ('B', c_ushort, 16)]
343 self.check_struct(X)
344 a = X()
345 a.A = 0
346 a.B = 1
347 self.assertEqual(1, a.B)
348
349 def test_mixed_6(self):
350 class X(Structure):
351 _fields_ = [
352 ('A', c_ulonglong, 1),
353 ('B', c_uint, 32)]
354 self.check_struct(X)
355 a = X()
356 a.A = 0
357 a.B = 1
358 self.assertEqual(1, a.B)
359
360 @unittest.skipIf(sizeof(c_uint64) != alignment(c_uint64),
361 'assumes size=alignment')
362 def test_mixed_7(self):
363 class X(Structure):
364 _fields_ = [
365 ("A", c_uint32),
366 ('B', c_uint32, 20),
367 ('C', c_uint64, 24)]
368 self.check_struct(X)
369 self.assertEqual(16, sizeof(X))
370
371 def test_mixed_8(self):
372 class Foo(Structure):
373 _fields_ = [
374 ("A", c_uint32),
375 ("B", c_uint32, 32),
376 ("C", c_ulonglong, 1),
377 ]
378 self.check_struct(Foo)
379
380 class Bar(Structure):
381 _fields_ = [
382 ("A", c_uint32),
383 ("B", c_uint32),
384 ("C", c_ulonglong, 1),
385 ]
386 self.check_struct(Bar)
387 self.assertEqual(sizeof(Foo), sizeof(Bar))
388
389 def test_mixed_9(self):
390 class X(Structure):
391 _fields_ = [
392 ("A", c_uint8),
393 ("B", c_uint32, 1),
394 ]
395 self.check_struct(X)
396 if sys.platform == 'win32':
397 self.assertEqual(8, sizeof(X))
398 else:
399 self.assertEqual(4, sizeof(X))
400
401 @unittest.skipIf(sizeof(c_uint64) != alignment(c_uint64),
402 'assumes size=alignment')
403 def test_mixed_10(self):
404 class X(Structure):
405 _fields_ = [
406 ("A", c_uint32, 1),
407 ("B", c_uint64, 1),
408 ]
409 self.check_struct(X)
410 if sys.platform == 'win32':
411 self.assertEqual(8, alignment(X))
412 self.assertEqual(16, sizeof(X))
413 else:
414 self.assertEqual(8, alignment(X))
415 self.assertEqual(8, sizeof(X))
416
417 def test_gh_95496(self):
418 for field_width in range(1, 33):
419 class TestStruct(Structure):
420 _fields_ = [
421 ("Field1", c_uint32, field_width),
422 ("Field2", c_uint8, 8)
423 ]
424 self.check_struct(TestStruct)
425
426 cmd = TestStruct()
427 cmd.Field2 = 1
428 self.assertEqual(1, cmd.Field2)
429
430 def test_gh_84039(self):
431 class Bad(Structure):
432 _pack_ = 1
433 _layout_ = "ms"
434 _fields_ = [
435 ("a0", c_uint8, 1),
436 ("a1", c_uint8, 1),
437 ("a2", c_uint8, 1),
438 ("a3", c_uint8, 1),
439 ("a4", c_uint8, 1),
440 ("a5", c_uint8, 1),
441 ("a6", c_uint8, 1),
442 ("a7", c_uint8, 1),
443 ("b0", c_uint16, 4),
444 ("b1", c_uint16, 12),
445 ]
446
447 class GoodA(Structure):
448 _pack_ = 1
449 _layout_ = "ms"
450 _fields_ = [
451 ("a0", c_uint8, 1),
452 ("a1", c_uint8, 1),
453 ("a2", c_uint8, 1),
454 ("a3", c_uint8, 1),
455 ("a4", c_uint8, 1),
456 ("a5", c_uint8, 1),
457 ("a6", c_uint8, 1),
458 ("a7", c_uint8, 1),
459 ]
460
461
462 class Good(Structure):
463 _pack_ = 1
464 _layout_ = "ms"
465 _fields_ = [
466 ("a", GoodA),
467 ("b0", c_uint16, 4),
468 ("b1", c_uint16, 12),
469 ]
470 self.check_struct(Bad)
471 self.check_struct(GoodA)
472 self.check_struct(Good)
473
474 self.assertEqual(3, sizeof(Bad))
475 self.assertEqual(3, sizeof(Good))
476
477 def test_gh_73939(self):
478 class MyStructure(Structure):
479 _pack_ = 1
480 _layout_ = "ms"
481 _fields_ = [
482 ("P", c_uint16),
483 ("L", c_uint16, 9),
484 ("Pro", c_uint16, 1),
485 ("G", c_uint16, 1),
486 ("IB", c_uint16, 1),
487 ("IR", c_uint16, 1),
488 ("R", c_uint16, 3),
489 ("T", c_uint32, 10),
490 ("C", c_uint32, 20),
491 ("R2", c_uint32, 2)
492 ]
493 self.check_struct(MyStructure)
494 self.assertEqual(8, sizeof(MyStructure))
495
496 def test_gh_86098(self):
497 class X(Structure):
498 _fields_ = [
499 ("a", c_uint8, 8),
500 ("b", c_uint8, 8),
501 ("c", c_uint32, 16)
502 ]
503 self.check_struct(X)
504 if sys.platform == 'win32':
505 self.assertEqual(8, sizeof(X))
506 else:
507 self.assertEqual(4, sizeof(X))
508
509 def test_anon_bitfields(self):
510 # anonymous bit-fields gave a strange error message
511 class X(Structure):
512 _fields_ = [("a", c_byte, 4),
513 ("b", c_ubyte, 4)]
514 class Y(Structure):
515 _anonymous_ = ["_"]
516 _fields_ = [("_", X)]
517
518 self.check_struct(X)
519 self.check_struct(Y)
520
521 def test_uint32(self):
522 class X(Structure):
523 _fields_ = [("a", c_uint32, 32)]
524 self.check_struct(X)
525 x = X()
526 x.a = 10
527 self.assertEqual(x.a, 10)
528 x.a = 0xFDCBA987
529 self.assertEqual(x.a, 0xFDCBA987)
530
531 def test_uint64(self):
532 class X(Structure):
533 _fields_ = [("a", c_uint64, 64)]
534 self.check_struct(X)
535 x = X()
536 x.a = 10
537 self.assertEqual(x.a, 10)
538 x.a = 0xFEDCBA9876543211
539 self.assertEqual(x.a, 0xFEDCBA9876543211)
540
541 def test_uint32_swap_little_endian(self):
542 # Issue #23319
543 class Little(LittleEndianStructure):
544 _fields_ = [("a", c_uint32, 24),
545 ("b", c_uint32, 4),
546 ("c", c_uint32, 4)]
547 self.check_struct(Little)
548 b = bytearray(4)
549 x = Little.from_buffer(b)
550 x.a = 0xabcdef
551 x.b = 1
552 x.c = 2
553 self.assertEqual(b, b'\xef\xcd\xab\x21')
554
555 def test_uint32_swap_big_endian(self):
556 # Issue #23319
557 class Big(BigEndianStructure):
558 _fields_ = [("a", c_uint32, 24),
559 ("b", c_uint32, 4),
560 ("c", c_uint32, 4)]
561 self.check_struct(Big)
562 b = bytearray(4)
563 x = Big.from_buffer(b)
564 x.a = 0xabcdef
565 x.b = 1
566 x.c = 2
567 self.assertEqual(b, b'\xab\xcd\xef\x12')
568
569 def test_union_bitfield(self):
570 class BitfieldUnion(Union):
571 _fields_ = [("a", c_uint32, 1),
572 ("b", c_uint32, 2),
573 ("c", c_uint32, 3)]
574 self.check_union(BitfieldUnion)
575 self.assertEqual(sizeof(BitfieldUnion), 4)
576 b = bytearray(4)
577 x = BitfieldUnion.from_buffer(b)
578 x.a = 1
579 self.assertEqual(int.from_bytes(b).bit_count(), 1)
580 x.b = 3
581 self.assertEqual(int.from_bytes(b).bit_count(), 2)
582 x.c = 7
583 self.assertEqual(int.from_bytes(b).bit_count(), 3)
584
585
586 if __name__ == "__main__":
587 unittest.main()