← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python3.4/trusty-proposed

« back to all changes in this revision

Viewing changes to Lib/ctypes/test/test_structures.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-11-25 09:44:27 UTC
  • Revision ID: package-import@ubuntu.com-20131125094427-lzxj8ap5w01lmo7f
Tags: upstream-3.4~b1
Import upstream version 3.4~b1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/ctypes/test/test_structures.py
 
1
import unittest
 
2
from ctypes import *
 
3
from struct import calcsize
 
4
import _testcapi
 
5
 
 
6
class SubclassesTest(unittest.TestCase):
 
7
    def test_subclass(self):
 
8
        class X(Structure):
 
9
            _fields_ = [("a", c_int)]
 
10
 
 
11
        class Y(X):
 
12
            _fields_ = [("b", c_int)]
 
13
 
 
14
        class Z(X):
 
15
            pass
 
16
 
 
17
        self.assertEqual(sizeof(X), sizeof(c_int))
 
18
        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
 
19
        self.assertEqual(sizeof(Z), sizeof(c_int))
 
20
        self.assertEqual(X._fields_, [("a", c_int)])
 
21
        self.assertEqual(Y._fields_, [("b", c_int)])
 
22
        self.assertEqual(Z._fields_, [("a", c_int)])
 
23
 
 
24
    def test_subclass_delayed(self):
 
25
        class X(Structure):
 
26
            pass
 
27
        self.assertEqual(sizeof(X), 0)
 
28
        X._fields_ = [("a", c_int)]
 
29
 
 
30
        class Y(X):
 
31
            pass
 
32
        self.assertEqual(sizeof(Y), sizeof(X))
 
33
        Y._fields_ = [("b", c_int)]
 
34
 
 
35
        class Z(X):
 
36
            pass
 
37
 
 
38
        self.assertEqual(sizeof(X), sizeof(c_int))
 
39
        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
 
40
        self.assertEqual(sizeof(Z), sizeof(c_int))
 
41
        self.assertEqual(X._fields_, [("a", c_int)])
 
42
        self.assertEqual(Y._fields_, [("b", c_int)])
 
43
        self.assertEqual(Z._fields_, [("a", c_int)])
 
44
 
 
45
class StructureTestCase(unittest.TestCase):
 
46
    formats = {"c": c_char,
 
47
               "b": c_byte,
 
48
               "B": c_ubyte,
 
49
               "h": c_short,
 
50
               "H": c_ushort,
 
51
               "i": c_int,
 
52
               "I": c_uint,
 
53
               "l": c_long,
 
54
               "L": c_ulong,
 
55
               "q": c_longlong,
 
56
               "Q": c_ulonglong,
 
57
               "f": c_float,
 
58
               "d": c_double,
 
59
               }
 
60
 
 
61
    def test_simple_structs(self):
 
62
        for code, tp in self.formats.items():
 
63
            class X(Structure):
 
64
                _fields_ = [("x", c_char),
 
65
                            ("y", tp)]
 
66
            self.assertEqual((sizeof(X), code),
 
67
                                 (calcsize("c%c0%c" % (code, code)), code))
 
68
 
 
69
    def test_unions(self):
 
70
        for code, tp in self.formats.items():
 
71
            class X(Union):
 
72
                _fields_ = [("x", c_char),
 
73
                            ("y", tp)]
 
74
            self.assertEqual((sizeof(X), code),
 
75
                                 (calcsize("%c" % (code)), code))
 
76
 
 
77
    def test_struct_alignment(self):
 
78
        class X(Structure):
 
79
            _fields_ = [("x", c_char * 3)]
 
80
        self.assertEqual(alignment(X), calcsize("s"))
 
81
        self.assertEqual(sizeof(X), calcsize("3s"))
 
82
 
 
83
        class Y(Structure):
 
84
            _fields_ = [("x", c_char * 3),
 
85
                        ("y", c_int)]
 
86
        self.assertEqual(alignment(Y), calcsize("i"))
 
87
        self.assertEqual(sizeof(Y), calcsize("3si"))
 
88
 
 
89
        class SI(Structure):
 
90
            _fields_ = [("a", X),
 
91
                        ("b", Y)]
 
92
        self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
 
93
        self.assertEqual(sizeof(SI), calcsize("3s0i 3si 0i"))
 
94
 
 
95
        class IS(Structure):
 
96
            _fields_ = [("b", Y),
 
97
                        ("a", X)]
 
98
 
 
99
        self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
 
100
        self.assertEqual(sizeof(IS), calcsize("3si 3s 0i"))
 
101
 
 
102
        class XX(Structure):
 
103
            _fields_ = [("a", X),
 
104
                        ("b", X)]
 
105
        self.assertEqual(alignment(XX), alignment(X))
 
106
        self.assertEqual(sizeof(XX), calcsize("3s 3s 0s"))
 
107
 
 
108
    def test_emtpy(self):
 
109
        # I had problems with these
 
110
        #
 
111
        # Although these are pathological cases: Empty Structures!
 
112
        class X(Structure):
 
113
            _fields_ = []
 
114
 
 
115
        class Y(Union):
 
116
            _fields_ = []
 
117
 
 
118
        # Is this really the correct alignment, or should it be 0?
 
119
        self.assertTrue(alignment(X) == alignment(Y) == 1)
 
120
        self.assertTrue(sizeof(X) == sizeof(Y) == 0)
 
121
 
 
122
        class XX(Structure):
 
123
            _fields_ = [("a", X),
 
124
                        ("b", X)]
 
125
 
 
126
        self.assertEqual(alignment(XX), 1)
 
127
        self.assertEqual(sizeof(XX), 0)
 
128
 
 
129
    def test_fields(self):
 
130
        # test the offset and size attributes of Structure/Unoin fields.
 
131
        class X(Structure):
 
132
            _fields_ = [("x", c_int),
 
133
                        ("y", c_char)]
 
134
 
 
135
        self.assertEqual(X.x.offset, 0)
 
136
        self.assertEqual(X.x.size, sizeof(c_int))
 
137
 
 
138
        self.assertEqual(X.y.offset, sizeof(c_int))
 
139
        self.assertEqual(X.y.size, sizeof(c_char))
 
140
 
 
141
        # readonly
 
142
        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
 
143
        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
 
144
 
 
145
        class X(Union):
 
146
            _fields_ = [("x", c_int),
 
147
                        ("y", c_char)]
 
148
 
 
149
        self.assertEqual(X.x.offset, 0)
 
150
        self.assertEqual(X.x.size, sizeof(c_int))
 
151
 
 
152
        self.assertEqual(X.y.offset, 0)
 
153
        self.assertEqual(X.y.size, sizeof(c_char))
 
154
 
 
155
        # readonly
 
156
        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
 
157
        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
 
158
 
 
159
        # XXX Should we check nested data types also?
 
160
        # offset is always relative to the class...
 
161
 
 
162
    def test_packed(self):
 
163
        class X(Structure):
 
164
            _fields_ = [("a", c_byte),
 
165
                        ("b", c_longlong)]
 
166
            _pack_ = 1
 
167
 
 
168
        self.assertEqual(sizeof(X), 9)
 
169
        self.assertEqual(X.b.offset, 1)
 
170
 
 
171
        class X(Structure):
 
172
            _fields_ = [("a", c_byte),
 
173
                        ("b", c_longlong)]
 
174
            _pack_ = 2
 
175
        self.assertEqual(sizeof(X), 10)
 
176
        self.assertEqual(X.b.offset, 2)
 
177
 
 
178
        class X(Structure):
 
179
            _fields_ = [("a", c_byte),
 
180
                        ("b", c_longlong)]
 
181
            _pack_ = 4
 
182
        self.assertEqual(sizeof(X), 12)
 
183
        self.assertEqual(X.b.offset, 4)
 
184
 
 
185
        import struct
 
186
        longlong_size = struct.calcsize("q")
 
187
        longlong_align = struct.calcsize("bq") - longlong_size
 
188
 
 
189
        class X(Structure):
 
190
            _fields_ = [("a", c_byte),
 
191
                        ("b", c_longlong)]
 
192
            _pack_ = 8
 
193
 
 
194
        self.assertEqual(sizeof(X), longlong_align + longlong_size)
 
195
        self.assertEqual(X.b.offset, min(8, longlong_align))
 
196
 
 
197
 
 
198
        d = {"_fields_": [("a", "b"),
 
199
                          ("b", "q")],
 
200
             "_pack_": -1}
 
201
        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
 
202
 
 
203
        # Issue 15989
 
204
        d = {"_fields_": [("a", c_byte)],
 
205
             "_pack_": _testcapi.INT_MAX + 1}
 
206
        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
 
207
        d = {"_fields_": [("a", c_byte)],
 
208
             "_pack_": _testcapi.UINT_MAX + 2}
 
209
        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
 
210
 
 
211
    def test_initializers(self):
 
212
        class Person(Structure):
 
213
            _fields_ = [("name", c_char*6),
 
214
                        ("age", c_int)]
 
215
 
 
216
        self.assertRaises(TypeError, Person, 42)
 
217
        self.assertRaises(ValueError, Person, b"asldkjaslkdjaslkdj")
 
218
        self.assertRaises(TypeError, Person, "Name", "HI")
 
219
 
 
220
        # short enough
 
221
        self.assertEqual(Person(b"12345", 5).name, b"12345")
 
222
        # exact fit
 
223
        self.assertEqual(Person(b"123456", 5).name, b"123456")
 
224
        # too long
 
225
        self.assertRaises(ValueError, Person, b"1234567", 5)
 
226
 
 
227
    def test_conflicting_initializers(self):
 
228
        class POINT(Structure):
 
229
            _fields_ = [("x", c_int), ("y", c_int)]
 
230
        # conflicting positional and keyword args
 
231
        self.assertRaises(TypeError, POINT, 2, 3, x=4)
 
232
        self.assertRaises(TypeError, POINT, 2, 3, y=4)
 
233
 
 
234
        # too many initializers
 
235
        self.assertRaises(TypeError, POINT, 2, 3, 4)
 
236
 
 
237
    def test_keyword_initializers(self):
 
238
        class POINT(Structure):
 
239
            _fields_ = [("x", c_int), ("y", c_int)]
 
240
        pt = POINT(1, 2)
 
241
        self.assertEqual((pt.x, pt.y), (1, 2))
 
242
 
 
243
        pt = POINT(y=2, x=1)
 
244
        self.assertEqual((pt.x, pt.y), (1, 2))
 
245
 
 
246
    def test_invalid_field_types(self):
 
247
        class POINT(Structure):
 
248
            pass
 
249
        self.assertRaises(TypeError, setattr, POINT, "_fields_", [("x", 1), ("y", 2)])
 
250
 
 
251
    def test_invalid_name(self):
 
252
        # field name must be string
 
253
        def declare_with_name(name):
 
254
            class S(Structure):
 
255
                _fields_ = [(name, c_int)]
 
256
 
 
257
        self.assertRaises(TypeError, declare_with_name, b"x")
 
258
 
 
259
    def test_intarray_fields(self):
 
260
        class SomeInts(Structure):
 
261
            _fields_ = [("a", c_int * 4)]
 
262
 
 
263
        # can use tuple to initialize array (but not list!)
 
264
        self.assertEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
 
265
        self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
 
266
        self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
 
267
        self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
 
268
        self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
 
269
        self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
 
270
        self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
 
271
        self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
 
272
        # too long
 
273
        # XXX Should raise ValueError?, not RuntimeError
 
274
        self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
 
275
 
 
276
    def test_nested_initializers(self):
 
277
        # test initializing nested structures
 
278
        class Phone(Structure):
 
279
            _fields_ = [("areacode", c_char*6),
 
280
                        ("number", c_char*12)]
 
281
 
 
282
        class Person(Structure):
 
283
            _fields_ = [("name", c_char * 12),
 
284
                        ("phone", Phone),
 
285
                        ("age", c_int)]
 
286
 
 
287
        p = Person(b"Someone", (b"1234", b"5678"), 5)
 
288
 
 
289
        self.assertEqual(p.name, b"Someone")
 
290
        self.assertEqual(p.phone.areacode, b"1234")
 
291
        self.assertEqual(p.phone.number, b"5678")
 
292
        self.assertEqual(p.age, 5)
 
293
 
 
294
    def test_structures_with_wchar(self):
 
295
        try:
 
296
            c_wchar
 
297
        except NameError:
 
298
            return # no unicode
 
299
 
 
300
        class PersonW(Structure):
 
301
            _fields_ = [("name", c_wchar * 12),
 
302
                        ("age", c_int)]
 
303
 
 
304
        p = PersonW("Someone \xe9")
 
305
        self.assertEqual(p.name, "Someone \xe9")
 
306
 
 
307
        self.assertEqual(PersonW("1234567890").name, "1234567890")
 
308
        self.assertEqual(PersonW("12345678901").name, "12345678901")
 
309
        # exact fit
 
310
        self.assertEqual(PersonW("123456789012").name, "123456789012")
 
311
        #too long
 
312
        self.assertRaises(ValueError, PersonW, "1234567890123")
 
313
 
 
314
    def test_init_errors(self):
 
315
        class Phone(Structure):
 
316
            _fields_ = [("areacode", c_char*6),
 
317
                        ("number", c_char*12)]
 
318
 
 
319
        class Person(Structure):
 
320
            _fields_ = [("name", c_char * 12),
 
321
                        ("phone", Phone),
 
322
                        ("age", c_int)]
 
323
 
 
324
        cls, msg = self.get_except(Person, b"Someone", (1, 2))
 
325
        self.assertEqual(cls, RuntimeError)
 
326
        self.assertEqual(msg,
 
327
                             "(Phone) <class 'TypeError'>: "
 
328
                             "expected string, int found")
 
329
 
 
330
        cls, msg = self.get_except(Person, b"Someone", (b"a", b"b", b"c"))
 
331
        self.assertEqual(cls, RuntimeError)
 
332
        if issubclass(Exception, object):
 
333
            self.assertEqual(msg,
 
334
                                 "(Phone) <class 'TypeError'>: too many initializers")
 
335
        else:
 
336
            self.assertEqual(msg, "(Phone) TypeError: too many initializers")
 
337
 
 
338
    def test_huge_field_name(self):
 
339
        # issue12881: segfault with large structure field names
 
340
        def create_class(length):
 
341
            class S(Structure):
 
342
                _fields_ = [('x' * length, c_int)]
 
343
 
 
344
        for length in [10 ** i for i in range(0, 8)]:
 
345
            try:
 
346
                create_class(length)
 
347
            except MemoryError:
 
348
                # MemoryErrors are OK, we just don't want to segfault
 
349
                pass
 
350
 
 
351
    def get_except(self, func, *args):
 
352
        try:
 
353
            func(*args)
 
354
        except Exception as detail:
 
355
            return detail.__class__, str(detail)
 
356
 
 
357
 
 
358
##    def test_subclass_creation(self):
 
359
##        meta = type(Structure)
 
360
##        # same as 'class X(Structure): pass'
 
361
##        # fails, since we need either a _fields_ or a _abstract_ attribute
 
362
##        cls, msg = self.get_except(meta, "X", (Structure,), {})
 
363
##        self.assertEqual((cls, msg),
 
364
##                             (AttributeError, "class must define a '_fields_' attribute"))
 
365
 
 
366
    def test_abstract_class(self):
 
367
        class X(Structure):
 
368
            _abstract_ = "something"
 
369
        # try 'X()'
 
370
        cls, msg = self.get_except(eval, "X()", locals())
 
371
        self.assertEqual((cls, msg), (TypeError, "abstract class"))
 
372
 
 
373
    def test_methods(self):
 
374
##        class X(Structure):
 
375
##            _fields_ = []
 
376
 
 
377
        self.assertIn("in_dll", dir(type(Structure)))
 
378
        self.assertIn("from_address", dir(type(Structure)))
 
379
        self.assertIn("in_dll", dir(type(Structure)))
 
380
 
 
381
    def test_positional_args(self):
 
382
        # see also http://bugs.python.org/issue5042
 
383
        class W(Structure):
 
384
            _fields_ = [("a", c_int), ("b", c_int)]
 
385
        class X(W):
 
386
            _fields_ = [("c", c_int)]
 
387
        class Y(X):
 
388
            pass
 
389
        class Z(Y):
 
390
            _fields_ = [("d", c_int), ("e", c_int), ("f", c_int)]
 
391
 
 
392
        z = Z(1, 2, 3, 4, 5, 6)
 
393
        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
 
394
                         (1, 2, 3, 4, 5, 6))
 
395
        z = Z(1)
 
396
        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
 
397
                         (1, 0, 0, 0, 0, 0))
 
398
        self.assertRaises(TypeError, lambda: Z(1, 2, 3, 4, 5, 6, 7))
 
399
 
 
400
class PointerMemberTestCase(unittest.TestCase):
 
401
 
 
402
    def test(self):
 
403
        # a Structure with a POINTER field
 
404
        class S(Structure):
 
405
            _fields_ = [("array", POINTER(c_int))]
 
406
 
 
407
        s = S()
 
408
        # We can assign arrays of the correct type
 
409
        s.array = (c_int * 3)(1, 2, 3)
 
410
        items = [s.array[i] for i in range(3)]
 
411
        self.assertEqual(items, [1, 2, 3])
 
412
 
 
413
        # The following are bugs, but are included here because the unittests
 
414
        # also describe the current behaviour.
 
415
        #
 
416
        # This fails with SystemError: bad arg to internal function
 
417
        # or with IndexError (with a patch I have)
 
418
 
 
419
        s.array[0] = 42
 
420
 
 
421
        items = [s.array[i] for i in range(3)]
 
422
        self.assertEqual(items, [42, 2, 3])
 
423
 
 
424
        s.array[0] = 1
 
425
 
 
426
##        s.array[1] = 42
 
427
 
 
428
        items = [s.array[i] for i in range(3)]
 
429
        self.assertEqual(items, [1, 2, 3])
 
430
 
 
431
    def test_none_to_pointer_fields(self):
 
432
        class S(Structure):
 
433
            _fields_ = [("x", c_int),
 
434
                        ("p", POINTER(c_int))]
 
435
 
 
436
        s = S()
 
437
        s.x = 12345678
 
438
        s.p = None
 
439
        self.assertEqual(s.x, 12345678)
 
440
 
 
441
class TestRecursiveStructure(unittest.TestCase):
 
442
    def test_contains_itself(self):
 
443
        class Recursive(Structure):
 
444
            pass
 
445
 
 
446
        try:
 
447
            Recursive._fields_ = [("next", Recursive)]
 
448
        except AttributeError as details:
 
449
            self.assertIn("Structure or union cannot contain itself",
 
450
                          str(details))
 
451
        else:
 
452
            self.fail("Structure or union cannot contain itself")
 
453
 
 
454
 
 
455
    def test_vice_versa(self):
 
456
        class First(Structure):
 
457
            pass
 
458
        class Second(Structure):
 
459
            pass
 
460
 
 
461
        First._fields_ = [("second", Second)]
 
462
 
 
463
        try:
 
464
            Second._fields_ = [("first", First)]
 
465
        except AttributeError as details:
 
466
            self.assertIn("_fields_ is final", str(details))
 
467
        else:
 
468
            self.fail("AttributeError not raised")
 
469
 
 
470
if __name__ == '__main__':
 
471
    unittest.main()