/Lib/ctypes/test/test_strings.py

http://unladen-swallow.googlecode.com/ · Python · 218 lines · 129 code · 54 blank · 35 comment · 8 complexity · d9c95e94e6754b6f6381030ad220013f MD5 · raw file

  1. import unittest
  2. from ctypes import *
  3. class StringArrayTestCase(unittest.TestCase):
  4. def test(self):
  5. BUF = c_char * 4
  6. buf = BUF("a", "b", "c")
  7. self.failUnlessEqual(buf.value, "abc")
  8. self.failUnlessEqual(buf.raw, "abc\000")
  9. buf.value = "ABCD"
  10. self.failUnlessEqual(buf.value, "ABCD")
  11. self.failUnlessEqual(buf.raw, "ABCD")
  12. buf.value = "x"
  13. self.failUnlessEqual(buf.value, "x")
  14. self.failUnlessEqual(buf.raw, "x\000CD")
  15. buf[1] = "Z"
  16. self.failUnlessEqual(buf.value, "xZCD")
  17. self.failUnlessEqual(buf.raw, "xZCD")
  18. self.assertRaises(ValueError, setattr, buf, "value", "aaaaaaaa")
  19. self.assertRaises(TypeError, setattr, buf, "value", 42)
  20. def test_c_buffer_value(self):
  21. buf = c_buffer(32)
  22. buf.value = "Hello, World"
  23. self.failUnlessEqual(buf.value, "Hello, World")
  24. self.failUnlessRaises(TypeError, setattr, buf, "value", buffer("Hello, World"))
  25. self.assertRaises(TypeError, setattr, buf, "value", buffer("abc"))
  26. self.assertRaises(ValueError, setattr, buf, "raw", buffer("x" * 100))
  27. def test_c_buffer_raw(self):
  28. buf = c_buffer(32)
  29. buf.raw = buffer("Hello, World")
  30. self.failUnlessEqual(buf.value, "Hello, World")
  31. self.assertRaises(TypeError, setattr, buf, "value", buffer("abc"))
  32. self.assertRaises(ValueError, setattr, buf, "raw", buffer("x" * 100))
  33. def test_param_1(self):
  34. BUF = c_char * 4
  35. buf = BUF()
  36. ## print c_char_p.from_param(buf)
  37. def test_param_2(self):
  38. BUF = c_char * 4
  39. buf = BUF()
  40. ## print BUF.from_param(c_char_p("python"))
  41. ## print BUF.from_param(BUF(*"pyth"))
  42. try:
  43. c_wchar
  44. except NameError:
  45. pass
  46. else:
  47. class WStringArrayTestCase(unittest.TestCase):
  48. def test(self):
  49. BUF = c_wchar * 4
  50. buf = BUF(u"a", u"b", u"c")
  51. self.failUnlessEqual(buf.value, u"abc")
  52. buf.value = u"ABCD"
  53. self.failUnlessEqual(buf.value, u"ABCD")
  54. buf.value = u"x"
  55. self.failUnlessEqual(buf.value, u"x")
  56. buf[1] = u"Z"
  57. self.failUnlessEqual(buf.value, u"xZCD")
  58. class StringTestCase(unittest.TestCase):
  59. def XX_test_basic_strings(self):
  60. cs = c_string("abcdef")
  61. # Cannot call len on a c_string any longer
  62. self.assertRaises(TypeError, len, cs)
  63. self.failUnlessEqual(sizeof(cs), 7)
  64. # The value property is the string up to the first terminating NUL.
  65. self.failUnlessEqual(cs.value, "abcdef")
  66. self.failUnlessEqual(c_string("abc\000def").value, "abc")
  67. # The raw property is the total buffer contents:
  68. self.failUnlessEqual(cs.raw, "abcdef\000")
  69. self.failUnlessEqual(c_string("abc\000def").raw, "abc\000def\000")
  70. # We can change the value:
  71. cs.value = "ab"
  72. self.failUnlessEqual(cs.value, "ab")
  73. self.failUnlessEqual(cs.raw, "ab\000\000\000\000\000")
  74. cs.raw = "XY"
  75. self.failUnlessEqual(cs.value, "XY")
  76. self.failUnlessEqual(cs.raw, "XY\000\000\000\000\000")
  77. self.assertRaises(TypeError, c_string, u"123")
  78. def XX_test_sized_strings(self):
  79. # New in releases later than 0.4.0:
  80. self.assertRaises(TypeError, c_string, None)
  81. # New in releases later than 0.4.0:
  82. # c_string(number) returns an empty string of size number
  83. self.failUnless(len(c_string(32).raw) == 32)
  84. self.assertRaises(ValueError, c_string, -1)
  85. self.assertRaises(ValueError, c_string, 0)
  86. # These tests fail, because it is no longer initialized
  87. ## self.failUnless(c_string(2).value == "")
  88. ## self.failUnless(c_string(2).raw == "\000\000")
  89. self.failUnless(c_string(2).raw[-1] == "\000")
  90. self.failUnless(len(c_string(2).raw) == 2)
  91. def XX_test_initialized_strings(self):
  92. self.failUnless(c_string("ab", 4).raw[:2] == "ab")
  93. self.failUnless(c_string("ab", 4).raw[:2:] == "ab")
  94. self.failUnless(c_string("ab", 4).raw[:2:-1] == "ba")
  95. self.failUnless(c_string("ab", 4).raw[:2:2] == "a")
  96. self.failUnless(c_string("ab", 4).raw[-1] == "\000")
  97. self.failUnless(c_string("ab", 2).raw == "a\000")
  98. def XX_test_toolong(self):
  99. cs = c_string("abcdef")
  100. # Much too long string:
  101. self.assertRaises(ValueError, setattr, cs, "value", "123456789012345")
  102. # One char too long values:
  103. self.assertRaises(ValueError, setattr, cs, "value", "1234567")
  104. ## def test_perf(self):
  105. ## check_perf()
  106. try:
  107. c_wchar
  108. except NameError:
  109. pass
  110. else:
  111. class WStringTestCase(unittest.TestCase):
  112. def test_wchar(self):
  113. c_wchar(u"x")
  114. repr(byref(c_wchar(u"x")))
  115. c_wchar("x")
  116. def X_test_basic_wstrings(self):
  117. cs = c_wstring(u"abcdef")
  118. # XXX This behaviour is about to change:
  119. # len returns the size of the internal buffer in bytes.
  120. # This includes the terminating NUL character.
  121. self.failUnless(sizeof(cs) == 14)
  122. # The value property is the string up to the first terminating NUL.
  123. self.failUnless(cs.value == u"abcdef")
  124. self.failUnless(c_wstring(u"abc\000def").value == u"abc")
  125. self.failUnless(c_wstring(u"abc\000def").value == u"abc")
  126. # The raw property is the total buffer contents:
  127. self.failUnless(cs.raw == u"abcdef\000")
  128. self.failUnless(c_wstring(u"abc\000def").raw == u"abc\000def\000")
  129. # We can change the value:
  130. cs.value = u"ab"
  131. self.failUnless(cs.value == u"ab")
  132. self.failUnless(cs.raw == u"ab\000\000\000\000\000")
  133. self.assertRaises(TypeError, c_wstring, "123")
  134. self.assertRaises(ValueError, c_wstring, 0)
  135. def X_test_toolong(self):
  136. cs = c_wstring(u"abcdef")
  137. # Much too long string:
  138. self.assertRaises(ValueError, setattr, cs, "value", u"123456789012345")
  139. # One char too long values:
  140. self.assertRaises(ValueError, setattr, cs, "value", u"1234567")
  141. def run_test(rep, msg, func, arg):
  142. items = range(rep)
  143. from time import clock
  144. start = clock()
  145. for i in items:
  146. func(arg); func(arg); func(arg); func(arg); func(arg)
  147. stop = clock()
  148. print "%20s: %.2f us" % (msg, ((stop-start)*1e6/5/rep))
  149. def check_perf():
  150. # Construct 5 objects
  151. REP = 200000
  152. run_test(REP, "c_string(None)", c_string, None)
  153. run_test(REP, "c_string('abc')", c_string, 'abc')
  154. # Python 2.3 -OO, win2k, P4 700 MHz:
  155. #
  156. # c_string(None): 1.75 us
  157. # c_string('abc'): 2.74 us
  158. # Python 2.2 -OO, win2k, P4 700 MHz:
  159. #
  160. # c_string(None): 2.95 us
  161. # c_string('abc'): 3.67 us
  162. if __name__ == '__main__':
  163. ## check_perf()
  164. unittest.main()