traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Issue #19591: Use specific asserts in ctype tests.

This commit is contained in:
Serhiy Storchaka 2013-11-17 00:06:02 +02:00
parent 1153757356
commit 52bbeacb9d
16 changed files with 84 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Lib/ctypes/test/test_arrays.py
View File

@ -87,8 +87,8 @@ class ArrayTestCase(unittest.TestCase):
self.assertEqual(values, [1, 2, 3, 4, 5]) self.assertEqual(values, [1, 2, 3, 4, 5])
def test_classcache(self): def test_classcache(self):
self.assertTrue(not ARRAY(c_int, 3) is ARRAY(c_int, 4)) self.assertIsNot(ARRAY(c_int, 3), ARRAY(c_int, 4))
self.assertTrue(ARRAY(c_int, 3) is ARRAY(c_int, 3)) self.assertIs(ARRAY(c_int, 3), ARRAY(c_int, 3))
def test_from_address(self): def test_from_address(self):
# Failed with 0.9.8, reported by JUrner # Failed with 0.9.8, reported by JUrner
@ -128,7 +128,7 @@ class ArrayTestCase(unittest.TestCase):
# Create a new array type based on it: # Create a new array type based on it:
t1 = my_int * 1 t1 = my_int * 1
t2 = my_int * 1 t2 = my_int * 1
self.assertTrue(t1 is t2) self.assertIs(t1, t2)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

2
Lib/ctypes/test/test_as_parameter.py
View File

@ -134,7 +134,7 @@ class BasicWrapTestCase(unittest.TestCase):
f.argtypes = [c_longlong, MyCallback] f.argtypes = [c_longlong, MyCallback]
def callback(value): def callback(value):
self.assertTrue(isinstance(value, (int, long))) self.assertIsInstance(value, (int, long))
return value & 0x7FFFFFFF return value & 0x7FFFFFFF
cb = MyCallback(callback) cb = MyCallback(callback)

10
Lib/ctypes/test/test_buffers.py
View File

@ -7,12 +7,12 @@ class StringBufferTestCase(unittest.TestCase):
b = create_string_buffer(32) b = create_string_buffer(32)
self.assertEqual(len(b), 32) self.assertEqual(len(b), 32)
self.assertEqual(sizeof(b), 32 * sizeof(c_char)) self.assertEqual(sizeof(b), 32 * sizeof(c_char))
self.assertTrue(type(b[0]) is str) self.assertIs(type(b[0]), str)
b = create_string_buffer("abc") b = create_string_buffer("abc")
self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(len(b), 4) # trailing nul char
self.assertEqual(sizeof(b), 4 * sizeof(c_char)) self.assertEqual(sizeof(b), 4 * sizeof(c_char))
self.assertTrue(type(b[0]) is str) self.assertIs(type(b[0]), str)
self.assertEqual(b[0], "a") self.assertEqual(b[0], "a")
self.assertEqual(b[:], "abc\0") self.assertEqual(b[:], "abc\0")
self.assertEqual(b[::], "abc\0") self.assertEqual(b[::], "abc\0")
@ -45,12 +45,12 @@ class StringBufferTestCase(unittest.TestCase):
b = create_unicode_buffer(32) b = create_unicode_buffer(32)
self.assertEqual(len(b), 32) self.assertEqual(len(b), 32)
self.assertEqual(sizeof(b), 32 * sizeof(c_wchar)) self.assertEqual(sizeof(b), 32 * sizeof(c_wchar))
self.assertTrue(type(b[0]) is unicode) self.assertIs(type(b[0]), unicode)
b = create_unicode_buffer(u"abc") b = create_unicode_buffer(u"abc")
self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(len(b), 4) # trailing nul char
self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
self.assertTrue(type(b[0]) is unicode) self.assertIs(type(b[0]), unicode)
self.assertEqual(b[0], u"a") self.assertEqual(b[0], u"a")
self.assertEqual(b[:], "abc\0") self.assertEqual(b[:], "abc\0")
self.assertEqual(b[::], "abc\0") self.assertEqual(b[::], "abc\0")
@ -62,7 +62,7 @@ class StringBufferTestCase(unittest.TestCase):
b = create_unicode_buffer("abc") b = create_unicode_buffer("abc")
self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(len(b), 4) # trailing nul char
self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
self.assertTrue(type(b[0]) is unicode) self.assertIs(type(b[0]), unicode)
self.assertEqual(b[0], u"a") self.assertEqual(b[0], u"a")
self.assertEqual(b[:], "abc\0") self.assertEqual(b[:], "abc\0")
self.assertEqual(b[::], "abc\0") self.assertEqual(b[::], "abc\0")

52
Lib/ctypes/test/test_byteswap.py
View File

@ -23,11 +23,11 @@ class Test(unittest.TestCase):
def test_endian_short(self): def test_endian_short(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.assertTrue(c_short.__ctype_le__ is c_short) self.assertIs(c_short.__ctype_le__, c_short)
self.assertTrue(c_short.__ctype_be__.__ctype_le__ is c_short) self.assertIs(c_short.__ctype_be__.__ctype_le__, c_short)
else: else:
self.assertTrue(c_short.__ctype_be__ is c_short) self.assertIs(c_short.__ctype_be__, c_short)
self.assertTrue(c_short.__ctype_le__.__ctype_be__ is c_short) self.assertIs(c_short.__ctype_le__.__ctype_be__, c_short)
s = c_short.__ctype_be__(0x1234) s = c_short.__ctype_be__(0x1234)
self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234") self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
self.assertEqual(bin(s), "1234") self.assertEqual(bin(s), "1234")
@ -50,11 +50,11 @@ class Test(unittest.TestCase):
def test_endian_int(self): def test_endian_int(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.assertTrue(c_int.__ctype_le__ is c_int) self.assertIs(c_int.__ctype_le__, c_int)
self.assertTrue(c_int.__ctype_be__.__ctype_le__ is c_int) self.assertIs(c_int.__ctype_be__.__ctype_le__, c_int)
else: else:
self.assertTrue(c_int.__ctype_be__ is c_int) self.assertIs(c_int.__ctype_be__, c_int)
self.assertTrue(c_int.__ctype_le__.__ctype_be__ is c_int) self.assertIs(c_int.__ctype_le__.__ctype_be__, c_int)
s = c_int.__ctype_be__(0x12345678) s = c_int.__ctype_be__(0x12345678)
self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678") self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
@ -78,11 +78,11 @@ class Test(unittest.TestCase):
def test_endian_longlong(self): def test_endian_longlong(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.assertTrue(c_longlong.__ctype_le__ is c_longlong) self.assertIs(c_longlong.__ctype_le__, c_longlong)
self.assertTrue(c_longlong.__ctype_be__.__ctype_le__ is c_longlong) self.assertIs(c_longlong.__ctype_be__.__ctype_le__, c_longlong)
else: else:
self.assertTrue(c_longlong.__ctype_be__ is c_longlong) self.assertIs(c_longlong.__ctype_be__, c_longlong)
self.assertTrue(c_longlong.__ctype_le__.__ctype_be__ is c_longlong) self.assertIs(c_longlong.__ctype_le__.__ctype_be__, c_longlong)
s = c_longlong.__ctype_be__(0x1234567890ABCDEF) s = c_longlong.__ctype_be__(0x1234567890ABCDEF)
self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF") self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
@ -106,11 +106,11 @@ class Test(unittest.TestCase):
def test_endian_float(self): def test_endian_float(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.assertTrue(c_float.__ctype_le__ is c_float) self.assertIs(c_float.__ctype_le__, c_float)
self.assertTrue(c_float.__ctype_be__.__ctype_le__ is c_float) self.assertIs(c_float.__ctype_be__.__ctype_le__, c_float)
else: else:
self.assertTrue(c_float.__ctype_be__ is c_float) self.assertIs(c_float.__ctype_be__, c_float)
self.assertTrue(c_float.__ctype_le__.__ctype_be__ is c_float) self.assertIs(c_float.__ctype_le__.__ctype_be__, c_float)
s = c_float(math.pi) s = c_float(math.pi)
self.assertEqual(bin(struct.pack("f", math.pi)), bin(s)) self.assertEqual(bin(struct.pack("f", math.pi)), bin(s))
# Hm, what's the precision of a float compared to a double? # Hm, what's the precision of a float compared to a double?
@ -124,11 +124,11 @@ class Test(unittest.TestCase):
def test_endian_double(self): def test_endian_double(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.assertTrue(c_double.__ctype_le__ is c_double) self.assertIs(c_double.__ctype_le__, c_double)
self.assertTrue(c_double.__ctype_be__.__ctype_le__ is c_double) self.assertIs(c_double.__ctype_be__.__ctype_le__, c_double)
else: else:
self.assertTrue(c_double.__ctype_be__ is c_double) self.assertIs(c_double.__ctype_be__, c_double)
self.assertTrue(c_double.__ctype_le__.__ctype_be__ is c_double) self.assertIs(c_double.__ctype_le__.__ctype_be__, c_double)
s = c_double(math.pi) s = c_double(math.pi)
self.assertEqual(s.value, math.pi) self.assertEqual(s.value, math.pi)
self.assertEqual(bin(struct.pack("d", math.pi)), bin(s)) self.assertEqual(bin(struct.pack("d", math.pi)), bin(s))
@ -140,14 +140,14 @@ class Test(unittest.TestCase):
self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s)) self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
def test_endian_other(self): def test_endian_other(self):
self.assertTrue(c_byte.__ctype_le__ is c_byte) self.assertIs(c_byte.__ctype_le__, c_byte)
self.assertTrue(c_byte.__ctype_be__ is c_byte) self.assertIs(c_byte.__ctype_be__, c_byte)
self.assertTrue(c_ubyte.__ctype_le__ is c_ubyte) self.assertIs(c_ubyte.__ctype_le__, c_ubyte)
self.assertTrue(c_ubyte.__ctype_be__ is c_ubyte) self.assertIs(c_ubyte.__ctype_be__, c_ubyte)
self.assertTrue(c_char.__ctype_le__ is c_char) self.assertIs(c_char.__ctype_le__, c_char)
self.assertTrue(c_char.__ctype_be__ is c_char) self.assertIs(c_char.__ctype_be__, c_char)
def test_struct_fields_1(self): def test_struct_fields_1(self):
if sys.byteorder == "little": if sys.byteorder == "little":

6
Lib/ctypes/test/test_cast.py
View File

@ -38,14 +38,14 @@ class Test(unittest.TestCase):
p = cast(array, POINTER(c_char_p)) p = cast(array, POINTER(c_char_p))
# array and p share a common _objects attribute # array and p share a common _objects attribute
self.assertTrue(p._objects is array._objects) self.assertIs(p._objects, array._objects)
self.assertEqual(array._objects, {'0': "foo bar", id(array): array}) self.assertEqual(array._objects, {'0': "foo bar", id(array): array})
p[0] = "spam spam" p[0] = "spam spam"
self.assertEqual(p._objects, {'0': "spam spam", id(array): array}) self.assertEqual(p._objects, {'0': "spam spam", id(array): array})
self.assertTrue(array._objects is p._objects) self.assertIs(array._objects, p._objects)
p[1] = "foo bar" p[1] = "foo bar"
self.assertEqual(p._objects, {'1': 'foo bar', '0': "spam spam", id(array): array}) self.assertEqual(p._objects, {'1': 'foo bar', '0': "spam spam", id(array): array})
self.assertTrue(array._objects is p._objects) self.assertIs(array._objects, p._objects)
def test_other(self): def test_other(self):
p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int)) p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int))

2
Lib/ctypes/test/test_frombuffer.py
View File

@ -23,7 +23,7 @@ class Test(unittest.TestCase):
a[0], a[-1] = 200, -200 a[0], a[-1] = 200, -200
self.assertEqual(x[:], a.tolist()) self.assertEqual(x[:], a.tolist())
self.assertTrue(a in x._objects.values()) self.assertIn(a, x._objects.values())
self.assertRaises(ValueError, self.assertRaises(ValueError,
c_int.from_buffer, a, -1) c_int.from_buffer, a, -1)

2
Lib/ctypes/test/test_funcptr.py
View File

@ -75,7 +75,7 @@ class CFuncPtrTestCase(unittest.TestCase):
## "lpfnWndProc", WNDPROC_2(wndproc)) ## "lpfnWndProc", WNDPROC_2(wndproc))
# instead: # instead:
self.assertTrue(WNDPROC is WNDPROC_2) self.assertIs(WNDPROC, WNDPROC_2)
# 'wndclass.lpfnWndProc' leaks 94 references. Why? # 'wndclass.lpfnWndProc' leaks 94 references. Why?
self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10) self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10)

2
Lib/ctypes/test/test_functions.py
View File

@ -306,7 +306,7 @@ class FunctionTestCase(unittest.TestCase):
f.argtypes = [c_longlong, MyCallback] f.argtypes = [c_longlong, MyCallback]
def callback(value): def callback(value):
self.assertTrue(isinstance(value, (int, long))) self.assertIsInstance(value, (int, long))
return value & 0x7FFFFFFF return value & 0x7FFFFFFF
cb = MyCallback(callback) cb = MyCallback(callback)

2
Lib/ctypes/test/test_loading.py
View File

@ -43,7 +43,7 @@ class LoaderTest(unittest.TestCase):
if os.name in ("nt", "ce"): if os.name in ("nt", "ce"):
def test_load_library(self): def test_load_library(self):
self.assertFalse(libc_name is None) self.assertIsNotNone(libc_name)
if is_resource_enabled("printing"): if is_resource_enabled("printing"):
print find_library("kernel32") print find_library("kernel32")
print find_library("user32") print find_library("user32")

6
Lib/ctypes/test/test_numbers.py
View File

@ -181,10 +181,10 @@ class NumberTestCase(unittest.TestCase):
a = array(t._type_, [3.14]) a = array(t._type_, [3.14])
v = t.from_address(a.buffer_info()[0]) v = t.from_address(a.buffer_info()[0])
self.assertEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
self.assertTrue(type(v) is t) self.assertIs(type(v), t)
a[0] = 2.3456e17 a[0] = 2.3456e17
self.assertEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
self.assertTrue(type(v) is t) self.assertIs(type(v), t)
def test_char_from_address(self): def test_char_from_address(self):
from ctypes import c_char from ctypes import c_char
@ -193,7 +193,7 @@ class NumberTestCase(unittest.TestCase):
a = array('c', 'x') a = array('c', 'x')
v = c_char.from_address(a.buffer_info()[0]) v = c_char.from_address(a.buffer_info()[0])
self.assertEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
self.assertTrue(type(v) is c_char) self.assertIs(type(v), c_char)
a[0] = '?' a[0] = '?'
self.assertEqual(v.value, a[0]) self.assertEqual(v.value, a[0])

4
Lib/ctypes/test/test_parameters.py
View File

@ -55,7 +55,7 @@ class SimpleTypesTestCase(unittest.TestCase):
# c_char_p.from_param on a Python String packs the string # c_char_p.from_param on a Python String packs the string
# into a cparam object # into a cparam object
s = "123" s = "123"
self.assertTrue(c_char_p.from_param(s)._obj is s) self.assertIs(c_char_p.from_param(s)._obj, s)
# new in 0.9.1: convert (encode) unicode to ascii # new in 0.9.1: convert (encode) unicode to ascii
self.assertEqual(c_char_p.from_param(u"123")._obj, "123") self.assertEqual(c_char_p.from_param(u"123")._obj, "123")
@ -66,7 +66,7 @@ class SimpleTypesTestCase(unittest.TestCase):
# calling c_char_p.from_param with a c_char_p instance # calling c_char_p.from_param with a c_char_p instance
# returns the argument itself: # returns the argument itself:
a = c_char_p("123") a = c_char_p("123")
self.assertTrue(c_char_p.from_param(a) is a) self.assertIs(c_char_p.from_param(a), a)
def test_cw_strings(self): def test_cw_strings(self):
from ctypes import byref from ctypes import byref

8
Lib/ctypes/test/test_pointers.py
View File

@ -78,7 +78,7 @@ class PointersTestCase(unittest.TestCase):
## i = c_int(42) ## i = c_int(42)
## callback(byref(i)) ## callback(byref(i))
## self.assertTrue(i.value == 84) ## self.assertEqual(i.value, 84)
doit(callback) doit(callback)
## print self.result ## print self.result
@ -91,11 +91,11 @@ class PointersTestCase(unittest.TestCase):
i = ct(42) i = ct(42)
p = pointer(i) p = pointer(i)
## print type(p.contents), ct ## print type(p.contents), ct
self.assertTrue(type(p.contents) is ct) self.assertIs(type(p.contents), ct)
# p.contents is the same as p[0] # p.contents is the same as p[0]
## print p.contents ## print p.contents
## self.assertTrue(p.contents == 42) ## self.assertEqual(p.contents, 42)
## self.assertTrue(p[0] == 42) ## self.assertEqual(p[0], 42)
self.assertRaises(TypeError, delitem, p, 0) self.assertRaises(TypeError, delitem, p, 0)

2
Lib/ctypes/test/test_python_api.py
View File

@ -61,7 +61,7 @@ class PythonAPITestCase(unittest.TestCase):
ref = grc(s) ref = grc(s)
# id(python-object) is the address # id(python-object) is the address
pyobj = PyObj_FromPtr(id(s)) pyobj = PyObj_FromPtr(id(s))
self.assertTrue(s is pyobj) self.assertIs(s, pyobj)
self.assertEqual(grc(s), ref + 1) self.assertEqual(grc(s), ref + 1)
del pyobj del pyobj

14
Lib/ctypes/test/test_refcounts.py
View File

@ -24,7 +24,7 @@ class RefcountTestCase(unittest.TestCase):
self.assertEqual(grc(callback), 2) self.assertEqual(grc(callback), 2)
cb = MyCallback(callback) cb = MyCallback(callback)
self.assertTrue(grc(callback) > 2) self.assertGreater(grc(callback), 2)
result = f(-10, cb) result = f(-10, cb)
self.assertEqual(result, -18) self.assertEqual(result, -18)
cb = None cb = None
@ -43,15 +43,15 @@ class RefcountTestCase(unittest.TestCase):
# the CFuncPtr instance holds at least one refcount on func: # the CFuncPtr instance holds at least one refcount on func:
f = OtherCallback(func) f = OtherCallback(func)
self.assertTrue(grc(func) > 2) self.assertGreater(grc(func), 2)
# and may release it again # and may release it again
del f del f
self.assertTrue(grc(func) >= 2) self.assertGreaterEqual(grc(func), 2)
# but now it must be gone # but now it must be gone
gc.collect() gc.collect()
self.assertTrue(grc(func) == 2) self.assertEqual(grc(func), 2)
class X(ctypes.Structure): class X(ctypes.Structure):
_fields_ = [("a", OtherCallback)] _fields_ = [("a", OtherCallback)]
@ -59,11 +59,11 @@ class RefcountTestCase(unittest.TestCase):
x.a = OtherCallback(func) x.a = OtherCallback(func)
# the CFuncPtr instance holds at least one refcount on func: # the CFuncPtr instance holds at least one refcount on func:
self.assertTrue(grc(func) > 2) self.assertGreater(grc(func), 2)
# and may release it again # and may release it again
del x del x
self.assertTrue(grc(func) >= 2) self.assertGreaterEqual(grc(func), 2)
# and now it must be gone again # and now it must be gone again
gc.collect() gc.collect()
@ -72,7 +72,7 @@ class RefcountTestCase(unittest.TestCase):
f = OtherCallback(func) f = OtherCallback(func)
# the CFuncPtr instance holds at least one refcount on func: # the CFuncPtr instance holds at least one refcount on func:
self.assertTrue(grc(func) > 2) self.assertGreater(grc(func), 2)
# create a cycle # create a cycle
f.cycle = f f.cycle = f

38
Lib/ctypes/test/test_strings.py
View File

@ -115,24 +115,24 @@ class StringTestCase(unittest.TestCase):
# New in releases later than 0.4.0: # New in releases later than 0.4.0:
# c_string(number) returns an empty string of size number # c_string(number) returns an empty string of size number
self.assertTrue(len(c_string(32).raw) == 32) self.assertEqual(len(c_string(32).raw), 32)
self.assertRaises(ValueError, c_string, -1) self.assertRaises(ValueError, c_string, -1)
self.assertRaises(ValueError, c_string, 0) self.assertRaises(ValueError, c_string, 0)
# These tests fail, because it is no longer initialized # These tests fail, because it is no longer initialized
## self.assertTrue(c_string(2).value == "") ## self.assertEqual(c_string(2).value, "")
## self.assertTrue(c_string(2).raw == "\000\000") ## self.assertEqual(c_string(2).raw, "\000\000")
self.assertTrue(c_string(2).raw[-1] == "\000") self.assertEqual(c_string(2).raw[-1], "\000")
self.assertTrue(len(c_string(2).raw) == 2) self.assertEqual(len(c_string(2).raw), 2)
def XX_test_initialized_strings(self): def XX_test_initialized_strings(self):
self.assertTrue(c_string("ab", 4).raw[:2] == "ab") self.assertEqual(c_string("ab", 4).raw[:2], "ab")
self.assertTrue(c_string("ab", 4).raw[:2:] == "ab") self.assertEqual(c_string("ab", 4).raw[:2:], "ab")
self.assertTrue(c_string("ab", 4).raw[:2:-1] == "ba") self.assertEqual(c_string("ab", 4).raw[:2:-1], "ba")
self.assertTrue(c_string("ab", 4).raw[:2:2] == "a") self.assertEqual(c_string("ab", 4).raw[:2:2], "a")
self.assertTrue(c_string("ab", 4).raw[-1] == "\000") self.assertEqual(c_string("ab", 4).raw[-1], "\000")
self.assertTrue(c_string("ab", 2).raw == "a\000") self.assertEqual(c_string("ab", 2).raw, "a\000")
def XX_test_toolong(self): def XX_test_toolong(self):
cs = c_string("abcdef") cs = c_string("abcdef")
@ -163,22 +163,22 @@ else:
# XXX This behaviour is about to change: # XXX This behaviour is about to change:
# len returns the size of the internal buffer in bytes. # len returns the size of the internal buffer in bytes.
# This includes the terminating NUL character. # This includes the terminating NUL character.
self.assertTrue(sizeof(cs) == 14) self.assertEqual(sizeof(cs), 14)
# The value property is the string up to the first terminating NUL. # The value property is the string up to the first terminating NUL.
self.assertTrue(cs.value == u"abcdef") self.assertEqual(cs.value, u"abcdef")
self.assertTrue(c_wstring(u"abc\000def").value == u"abc") self.assertEqual(c_wstring(u"abc\000def").value, u"abc")
self.assertTrue(c_wstring(u"abc\000def").value == u"abc") self.assertEqual(c_wstring(u"abc\000def").value, u"abc")
# The raw property is the total buffer contents: # The raw property is the total buffer contents:
self.assertTrue(cs.raw == u"abcdef\000") self.assertEqual(cs.raw, u"abcdef\000")
self.assertTrue(c_wstring(u"abc\000def").raw == u"abc\000def\000") self.assertEqual(c_wstring(u"abc\000def").raw, u"abc\000def\000")
# We can change the value: # We can change the value:
cs.value = u"ab" cs.value = u"ab"
self.assertTrue(cs.value == u"ab") self.assertEqual(cs.value, u"ab")
self.assertTrue(cs.raw == u"ab\000\000\000\000\000") self.assertEqual(cs.raw, u"ab\000\000\000\000\000")
self.assertRaises(TypeError, c_wstring, "123") self.assertRaises(TypeError, c_wstring, "123")
self.assertRaises(ValueError, c_wstring, 0) self.assertRaises(ValueError, c_wstring, 0)

13
Lib/ctypes/test/test_structures.py
View File

@ -380,9 +380,9 @@ class StructureTestCase(unittest.TestCase):
## class X(Structure): ## class X(Structure):
## _fields_ = [] ## _fields_ = []
self.assertTrue("in_dll" in dir(type(Structure))) self.assertIn("in_dll", dir(type(Structure)))
self.assertTrue("from_address" in dir(type(Structure))) self.assertIn("from_address", dir(type(Structure)))
self.assertTrue("in_dll" in dir(type(Structure))) self.assertIn("in_dll", dir(type(Structure)))
def test_positional_args(self): def test_positional_args(self):
# see also http://bugs.python.org/issue5042 # see also http://bugs.python.org/issue5042
@ -452,8 +452,8 @@ class TestRecursiveStructure(unittest.TestCase):
try: try:
Recursive._fields_ = [("next", Recursive)] Recursive._fields_ = [("next", Recursive)]
except AttributeError, details: except AttributeError, details:
self.assertTrue("Structure or union cannot contain itself" in self.assertIn("Structure or union cannot contain itself",
str(details)) str(details))
else: else:
self.fail("Structure or union cannot contain itself") self.fail("Structure or union cannot contain itself")
@ -469,8 +469,7 @@ class TestRecursiveStructure(unittest.TestCase):
try: try:
Second._fields_ = [("first", First)] Second._fields_ = [("first", First)]
except AttributeError, details: except AttributeError, details:
self.assertTrue("_fields_ is final" in self.assertIn("_fields_ is final", str(details))
str(details))
else: else:
self.fail("AttributeError not raised") self.fail("AttributeError not raised")