/Lib/ctypes/test/test_structures.py

http://unladen-swallow.googlecode.com/ · Python · 449 lines · 320 code · 89 blank · 40 comment · 20 complexity · b03c1518dfcdce9b2a58111ffcd2255b MD5 · raw file

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