Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-11-03 23:21:29 +00:00
Code Issues Projects Releases Packages Wiki Activity

convert old fail* assertions to assert*

Browse source
This commit is contained in:
Benjamin Peterson 2009-06-30 23:06:06 +00:00
parent 98d23f2e06
commit c9c0f201fe
275 changed files with 4540 additions and 4540 deletions
Download patch file Download diff file Expand all files Collapse all files

22
Lib/ctypes/test/test_anon.py
View file

@ -14,22 +14,22 @@ class Y(Structure):
("y", c_int)] ("y", c_int)]
_anonymous_ = ["_"] _anonymous_ = ["_"]
self.failUnlessEqual(Y.a.offset, sizeof(c_int)) self.assertEqual(Y.a.offset, sizeof(c_int))
self.failUnlessEqual(Y.b.offset, sizeof(c_int)) self.assertEqual(Y.b.offset, sizeof(c_int))
self.failUnlessEqual(ANON.a.offset, 0) self.assertEqual(ANON.a.offset, 0)
self.failUnlessEqual(ANON.b.offset, 0) self.assertEqual(ANON.b.offset, 0)
def test_anon_nonseq(self): def test_anon_nonseq(self):
# TypeError: _anonymous_ must be a sequence # TypeError: _anonymous_ must be a sequence
self.failUnlessRaises(TypeError, self.assertRaises(TypeError,
lambda: type(Structure)("Name", lambda: type(Structure)("Name",
(Structure,), (Structure,),
{"_fields_": [], "_anonymous_": 42})) {"_fields_": [], "_anonymous_": 42}))
def test_anon_nonmember(self): def test_anon_nonmember(self):
# AttributeError: type object 'Name' has no attribute 'x' # AttributeError: type object 'Name' has no attribute 'x'
self.failUnlessRaises(AttributeError, self.assertRaises(AttributeError,
lambda: type(Structure)("Name", lambda: type(Structure)("Name",
(Structure,), (Structure,),
{"_fields_": [], {"_fields_": [],
@ -50,11 +50,11 @@ class Y(Structure):
("y", c_int)] ("y", c_int)]
_anonymous_ = ["_"] _anonymous_ = ["_"]
self.failUnlessEqual(Y.x.offset, 0) self.assertEqual(Y.x.offset, 0)
self.failUnlessEqual(Y.a.offset, sizeof(c_int)) self.assertEqual(Y.a.offset, sizeof(c_int))
self.failUnlessEqual(Y.b.offset, sizeof(c_int)) self.assertEqual(Y.b.offset, sizeof(c_int))
self.failUnlessEqual(Y._.offset, sizeof(c_int)) self.assertEqual(Y._.offset, sizeof(c_int))
self.failUnlessEqual(Y.y.offset, sizeof(c_int) * 2) self.assertEqual(Y.y.offset, sizeof(c_int) * 2)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

8
Lib/ctypes/test/test_array_in_pointer.py
View file

@ -26,7 +26,7 @@ def test(self):
c.pvalues = val_array c.pvalues = val_array
# memory contains 4 NUL bytes now, that's correct # memory contains 4 NUL bytes now, that's correct
self.failUnlessEqual("00-00-00-00", dump(val_array)) self.assertEqual("00-00-00-00", dump(val_array))
# set the values of the array through the pointer: # set the values of the array through the pointer:
for i in range(4): for i in range(4):
@ -35,7 +35,7 @@ def test(self):
values = [c.pvalues[i].val for i in range(4)] values = [c.pvalues[i].val for i in range(4)]
# These are the expected results: here s the bug! # These are the expected results: here s the bug!
self.failUnlessEqual( self.assertEqual(
(values, dump(val_array)), (values, dump(val_array)),
([1, 2, 3, 4], "01-02-03-04") ([1, 2, 3, 4], "01-02-03-04")
) )
@ -45,7 +45,7 @@ def test_2(self):
val_array = (Value * 4)() val_array = (Value * 4)()
# memory contains 4 NUL bytes now, that's correct # memory contains 4 NUL bytes now, that's correct
self.failUnlessEqual("00-00-00-00", dump(val_array)) self.assertEqual("00-00-00-00", dump(val_array))
ptr = cast(val_array, POINTER(Value)) ptr = cast(val_array, POINTER(Value))
# set the values of the array through the pointer: # set the values of the array through the pointer:
@ -55,7 +55,7 @@ def test_2(self):
values = [ptr[i].val for i in range(4)] values = [ptr[i].val for i in range(4)]
# These are the expected results: here s the bug! # These are the expected results: here s the bug!
self.failUnlessEqual( self.assertEqual(
(values, dump(val_array)), (values, dump(val_array)),
([1, 2, 3, 4], "01-02-03-04") ([1, 2, 3, 4], "01-02-03-04")
) )

60
Lib/ctypes/test/test_arrays.py
View file

@ -19,23 +19,23 @@ def test_simple(self):
ia = int_array(*init) ia = int_array(*init)
# length of instance ok? # length of instance ok?
self.failUnlessEqual(len(ia), alen) self.assertEqual(len(ia), alen)
# slot values ok? # slot values ok?
values = [ia[i] for i in range(len(init))] values = [ia[i] for i in range(len(init))]
self.failUnlessEqual(values, init) self.assertEqual(values, init)
# change the items # change the items
from operator import setitem from operator import setitem
new_values = list(range(42, 42+alen)) new_values = list(range(42, 42+alen))
[setitem(ia, n, new_values[n]) for n in range(alen)] [setitem(ia, n, new_values[n]) for n in range(alen)]
values = [ia[i] for i in range(len(init))] values = [ia[i] for i in range(len(init))]
self.failUnlessEqual(values, new_values) self.assertEqual(values, new_values)
# are the items initialized to 0? # are the items initialized to 0?
ia = int_array() ia = int_array()
values = [ia[i] for i in range(len(init))] values = [ia[i] for i in range(len(init))]
self.failUnlessEqual(values, [0] * len(init)) self.assertEqual(values, [0] * len(init))
# Too many in itializers should be caught # Too many in itializers should be caught
self.assertRaises(IndexError, int_array, *range(alen*2)) self.assertRaises(IndexError, int_array, *range(alen*2))
@ -48,14 +48,14 @@ def test_simple(self):
# CharArray("abc") # CharArray("abc")
self.assertRaises(TypeError, CharArray, "abc") self.assertRaises(TypeError, CharArray, "abc")
self.failUnlessEqual(ca[0], b"a") self.assertEqual(ca[0], b"a")
self.failUnlessEqual(ca[1], b"b") self.assertEqual(ca[1], b"b")
self.failUnlessEqual(ca[2], b"c") self.assertEqual(ca[2], b"c")
self.failUnlessEqual(ca[-3], b"a") self.assertEqual(ca[-3], b"a")
self.failUnlessEqual(ca[-2], b"b") self.assertEqual(ca[-2], b"b")
self.failUnlessEqual(ca[-1], b"c") self.assertEqual(ca[-1], b"c")
self.failUnlessEqual(len(ca), 3) self.assertEqual(len(ca), 3)
# cannot delete items # cannot delete items
from operator import delitem from operator import delitem
@ -69,34 +69,34 @@ def test_numeric_arrays(self):
na = numarray() na = numarray()
values = [na[i] for i in range(alen)] values = [na[i] for i in range(alen)]
self.failUnlessEqual(values, [0] * alen) self.assertEqual(values, [0] * alen)
na = numarray(*[c_int()] * alen) na = numarray(*[c_int()] * alen)
values = [na[i] for i in range(alen)] values = [na[i] for i in range(alen)]
self.failUnlessEqual(values, [0]*alen) self.assertEqual(values, [0]*alen)
na = numarray(1, 2, 3, 4, 5) na = numarray(1, 2, 3, 4, 5)
values = [i for i in na] values = [i for i in na]
self.failUnlessEqual(values, [1, 2, 3, 4, 5]) self.assertEqual(values, [1, 2, 3, 4, 5])
na = numarray(*map(c_int, (1, 2, 3, 4, 5))) na = numarray(*map(c_int, (1, 2, 3, 4, 5)))
values = [i for i in na] values = [i for i in na]
self.failUnlessEqual(values, [1, 2, 3, 4, 5]) self.assertEqual(values, [1, 2, 3, 4, 5])
def test_classcache(self): def test_classcache(self):
self.failUnless(not ARRAY(c_int, 3) is ARRAY(c_int, 4)) self.assertTrue(not ARRAY(c_int, 3) is ARRAY(c_int, 4))
self.failUnless(ARRAY(c_int, 3) is ARRAY(c_int, 3)) self.assertTrue(ARRAY(c_int, 3) is 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
p = create_string_buffer("foo") p = create_string_buffer("foo")
sz = (c_char * 3).from_address(addressof(p)) sz = (c_char * 3).from_address(addressof(p))
self.failUnlessEqual(sz[:], b"foo") self.assertEqual(sz[:], b"foo")
self.failUnlessEqual(sz[::], b"foo") self.assertEqual(sz[::], b"foo")
self.failUnlessEqual(sz[::-1], b"oof") self.assertEqual(sz[::-1], b"oof")
self.failUnlessEqual(sz[::3], b"f") self.assertEqual(sz[::3], b"f")
self.failUnlessEqual(sz[1:4:2], b"o") self.assertEqual(sz[1:4:2], b"o")
self.failUnlessEqual(sz.value, b"foo") self.assertEqual(sz.value, b"foo")
try: try:
create_unicode_buffer create_unicode_buffer
@ -106,12 +106,12 @@ def test_from_address(self):
def test_from_addressW(self): def test_from_addressW(self):
p = create_unicode_buffer("foo") p = create_unicode_buffer("foo")
sz = (c_wchar * 3).from_address(addressof(p)) sz = (c_wchar * 3).from_address(addressof(p))
self.failUnlessEqual(sz[:], "foo") self.assertEqual(sz[:], "foo")
self.failUnlessEqual(sz[::], "foo") self.assertEqual(sz[::], "foo")
self.failUnlessEqual(sz[::-1], "oof") self.assertEqual(sz[::-1], "oof")
self.failUnlessEqual(sz[::3], "f") self.assertEqual(sz[::3], "f")
self.failUnlessEqual(sz[1:4:2], "o") self.assertEqual(sz[1:4:2], "o")
self.failUnlessEqual(sz.value, "foo") self.assertEqual(sz.value, "foo")
def test_cache(self): def test_cache(self):
# Array types are cached internally in the _ctypes extension, # Array types are cached internally in the _ctypes extension,
@ -125,7 +125,7 @@ class my_int(c_int):
# 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.failUnless(t1 is t2) self.assertTrue(t1 is t2)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

38
Lib/ctypes/test/test_as_parameter.py
View file

@ -25,8 +25,8 @@ def test_wchar_parm(self):
f = dll._testfunc_i_bhilfd f = dll._testfunc_i_bhilfd
f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double] f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
result = f(self.wrap(1), self.wrap("x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0)) result = f(self.wrap(1), self.wrap("x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0))
self.failUnlessEqual(result, 139) self.assertEqual(result, 139)
self.failUnless(type(result), int) self.assertTrue(type(result), int)
def test_pointers(self): def test_pointers(self):
f = dll._testfunc_p_p f = dll._testfunc_p_p
@ -39,18 +39,18 @@ def test_pointers(self):
v = c_int(42) v = c_int(42)
self.failUnlessEqual(pointer(v).contents.value, 42) self.assertEqual(pointer(v).contents.value, 42)
result = f(self.wrap(pointer(v))) result = f(self.wrap(pointer(v)))
self.failUnlessEqual(type(result), POINTER(c_int)) self.assertEqual(type(result), POINTER(c_int))
self.failUnlessEqual(result.contents.value, 42) self.assertEqual(result.contents.value, 42)
# This on works... # This on works...
result = f(self.wrap(pointer(v))) result = f(self.wrap(pointer(v)))
self.failUnlessEqual(result.contents.value, v.value) self.assertEqual(result.contents.value, v.value)
p = pointer(c_int(99)) p = pointer(c_int(99))
result = f(self.wrap(p)) result = f(self.wrap(p))
self.failUnlessEqual(result.contents.value, 99) self.assertEqual(result.contents.value, 99)
def test_shorts(self): def test_shorts(self):
f = dll._testfunc_callback_i_if f = dll._testfunc_callback_i_if
@ -67,7 +67,7 @@ def callback(v):
cb = CallBack(callback) cb = CallBack(callback)
f(self.wrap(2**18), self.wrap(cb)) f(self.wrap(2**18), self.wrap(cb))
self.failUnlessEqual(args, expected) self.assertEqual(args, expected)
################################################################ ################################################################
@ -84,17 +84,17 @@ def callback(value):
cb = MyCallback(callback) cb = MyCallback(callback)
result = f(self.wrap(-10), self.wrap(cb)) result = f(self.wrap(-10), self.wrap(cb))
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
# test with prototype # test with prototype
f.argtypes = [c_int, MyCallback] f.argtypes = [c_int, MyCallback]
cb = MyCallback(callback) cb = MyCallback(callback)
result = f(self.wrap(-10), self.wrap(cb)) result = f(self.wrap(-10), self.wrap(cb))
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
result = f(self.wrap(-10), self.wrap(cb)) result = f(self.wrap(-10), self.wrap(cb))
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
AnotherCallback = CALLBACK_FUNCTYPE(c_int, c_int, c_int, c_int, c_int) AnotherCallback = CALLBACK_FUNCTYPE(c_int, c_int, c_int, c_int, c_int)
@ -116,12 +116,12 @@ def test_callbacks_2(self):
def callback(value): def callback(value):
#print "called back with", value #print "called back with", value
self.failUnlessEqual(type(value), int) self.assertEqual(type(value), int)
return value return value
cb = MyCallback(callback) cb = MyCallback(callback)
result = f(self.wrap(-10), self.wrap(cb)) result = f(self.wrap(-10), self.wrap(cb))
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
def test_longlong_callbacks(self): def test_longlong_callbacks(self):
@ -133,12 +133,12 @@ def test_longlong_callbacks(self):
f.argtypes = [c_longlong, MyCallback] f.argtypes = [c_longlong, MyCallback]
def callback(value): def callback(value):
self.failUnless(isinstance(value, int)) self.assertTrue(isinstance(value, int))
return value & 0x7FFFFFFF return value & 0x7FFFFFFF
cb = MyCallback(callback) cb = MyCallback(callback)
self.failUnlessEqual(13577625587, int(f(self.wrap(1000000000000), self.wrap(cb)))) self.assertEqual(13577625587, int(f(self.wrap(1000000000000), self.wrap(cb))))
def test_byval(self): def test_byval(self):
# without prototype # without prototype
@ -148,7 +148,7 @@ def test_byval(self):
result = dll._testfunc_byval(ptin, byref(ptout)) result = dll._testfunc_byval(ptin, byref(ptout))
got = result, ptout.x, ptout.y got = result, ptout.x, ptout.y
expected = 3, 1, 2 expected = 3, 1, 2
self.failUnlessEqual(got, expected) self.assertEqual(got, expected)
# with prototype # with prototype
ptin = POINT(101, 102) ptin = POINT(101, 102)
@ -158,7 +158,7 @@ def test_byval(self):
result = dll._testfunc_byval(self.wrap(ptin), byref(ptout)) result = dll._testfunc_byval(self.wrap(ptin), byref(ptout))
got = result, ptout.x, ptout.y got = result, ptout.x, ptout.y
expected = 203, 101, 102 expected = 203, 101, 102
self.failUnlessEqual(got, expected) self.assertEqual(got, expected)
def test_struct_return_2H(self): def test_struct_return_2H(self):
class S2H(Structure): class S2H(Structure):
@ -168,7 +168,7 @@ class S2H(Structure):
dll.ret_2h_func.argtypes = [S2H] dll.ret_2h_func.argtypes = [S2H]
inp = S2H(99, 88) inp = S2H(99, 88)
s2h = dll.ret_2h_func(self.wrap(inp)) s2h = dll.ret_2h_func(self.wrap(inp))
self.failUnlessEqual((s2h.x, s2h.y), (99*2, 88*3)) self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
def test_struct_return_8H(self): def test_struct_return_8H(self):
class S8I(Structure): class S8I(Structure):
@ -184,7 +184,7 @@ class S8I(Structure):
dll.ret_8i_func.argtypes = [S8I] dll.ret_8i_func.argtypes = [S8I]
inp = S8I(9, 8, 7, 6, 5, 4, 3, 2) inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
s8i = dll.ret_8i_func(self.wrap(inp)) s8i = dll.ret_8i_func(self.wrap(inp))
self.failUnlessEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
(9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9)) (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

84
Lib/ctypes/test/test_bitfields.py
View file

@ -37,14 +37,14 @@ def test_ints(self):
for name in "ABCDEFGHI": for name in "ABCDEFGHI":
b = BITS() b = BITS()
setattr(b, name, i) setattr(b, name, i)
self.failUnlessEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) self.assertEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name)))
def test_shorts(self): def test_shorts(self):
for i in range(256): for i in range(256):
for name in "MNOPQRS": for name in "MNOPQRS":
b = BITS() b = BITS()
setattr(b, name, i) setattr(b, name, i)
self.failUnlessEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) self.assertEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name)))
signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong) signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong)
unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong) unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
@ -58,10 +58,10 @@ class X(Structure):
("b", c_longlong, 62), ("b", c_longlong, 62),
("c", c_longlong, 1)] ("c", c_longlong, 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_longlong)) self.assertEqual(sizeof(X), sizeof(c_longlong))
x = X() x = X()
x.a, x.b, x.c = -1, 7, -1 x.a, x.b, x.c = -1, 7, -1
self.failUnlessEqual((x.a, x.b, x.c), (-1, 7, -1)) self.assertEqual((x.a, x.b, x.c), (-1, 7, -1))
def test_ulonglong(self): def test_ulonglong(self):
class X(Structure): class X(Structure):
@ -69,11 +69,11 @@ class X(Structure):
("b", c_ulonglong, 62), ("b", c_ulonglong, 62),
("c", c_ulonglong, 1)] ("c", c_ulonglong, 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_longlong)) self.assertEqual(sizeof(X), sizeof(c_longlong))
x = X() x = X()
self.failUnlessEqual((x.a, x.b, x.c), (0, 0, 0)) self.assertEqual((x.a, x.b, x.c), (0, 0, 0))
x.a, x.b, x.c = 7, 7, 7 x.a, x.b, x.c = 7, 7, 7
self.failUnlessEqual((x.a, x.b, x.c), (1, 7, 1)) self.assertEqual((x.a, x.b, x.c), (1, 7, 1))
def test_signed(self): def test_signed(self):
for c_typ in signed_int_types: for c_typ in signed_int_types:
@ -82,14 +82,14 @@ class X(Structure):
("a", c_typ, 3), ("a", c_typ, 3),
("b", c_typ, 3), ("b", c_typ, 3),
("c", c_typ, 1)] ("c", c_typ, 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_typ)*2) self.assertEqual(sizeof(X), sizeof(c_typ)*2)
x = X() x = X()
self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0)) self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
x.a = -1 x.a = -1
self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0)) self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0))
x.a, x.b = 0, -1 x.a, x.b = 0, -1
self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0)) self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0))
def test_unsigned(self): def test_unsigned(self):
@ -98,14 +98,14 @@ class X(Structure):
_fields_ = [("a", c_typ, 3), _fields_ = [("a", c_typ, 3),
("b", c_typ, 3), ("b", c_typ, 3),
("c", c_typ, 1)] ("c", c_typ, 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_typ)) self.assertEqual(sizeof(X), sizeof(c_typ))
x = X() x = X()
self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0)) self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
x.a = -1 x.a = -1
self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0)) self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0))
x.a, x.b = 0, -1 x.a, x.b = 0, -1
self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0)) self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0))
def fail_fields(self, *fields): def fail_fields(self, *fields):
@ -115,17 +115,17 @@ def fail_fields(self, *fields):
def test_nonint_types(self): def test_nonint_types(self):
# bit fields are not allowed on non-integer types. # bit fields are not allowed on non-integer types.
result = self.fail_fields(("a", c_char_p, 1)) result = self.fail_fields(("a", c_char_p, 1))
self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_char_p')) self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char_p'))
result = self.fail_fields(("a", c_void_p, 1)) result = self.fail_fields(("a", c_void_p, 1))
self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_void_p')) self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_void_p'))
if c_int != c_long: if c_int != c_long:
result = self.fail_fields(("a", POINTER(c_int), 1)) result = self.fail_fields(("a", POINTER(c_int), 1))
self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int')) self.assertEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int'))
result = self.fail_fields(("a", c_char, 1)) result = self.fail_fields(("a", c_char, 1))
self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_char')) self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char'))
try: try:
c_wchar c_wchar
@ -133,59 +133,59 @@ def test_nonint_types(self):
pass pass
else: else:
result = self.fail_fields(("a", c_wchar, 1)) result = self.fail_fields(("a", c_wchar, 1))
self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_wchar')) self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_wchar'))
class Dummy(Structure): class Dummy(Structure):
_fields_ = [] _fields_ = []
result = self.fail_fields(("a", Dummy, 1)) result = self.fail_fields(("a", Dummy, 1))
self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type Dummy')) self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy'))
def test_single_bitfield_size(self): def test_single_bitfield_size(self):
for c_typ in int_types: for c_typ in int_types:
result = self.fail_fields(("a", c_typ, -1)) result = self.fail_fields(("a", c_typ, -1))
self.failUnlessEqual(result, (ValueError, 'number of bits invalid for bit field')) self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
result = self.fail_fields(("a", c_typ, 0)) result = self.fail_fields(("a", c_typ, 0))
self.failUnlessEqual(result, (ValueError, 'number of bits invalid for bit field')) self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
class X(Structure): class X(Structure):
_fields_ = [("a", c_typ, 1)] _fields_ = [("a", c_typ, 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_typ)) self.assertEqual(sizeof(X), sizeof(c_typ))
class X(Structure): class X(Structure):
_fields_ = [("a", c_typ, sizeof(c_typ)*8)] _fields_ = [("a", c_typ, sizeof(c_typ)*8)]
self.failUnlessEqual(sizeof(X), sizeof(c_typ)) self.assertEqual(sizeof(X), sizeof(c_typ))
result = self.fail_fields(("a", c_typ, sizeof(c_typ)*8 + 1)) result = self.fail_fields(("a", c_typ, sizeof(c_typ)*8 + 1))
self.failUnlessEqual(result, (ValueError, 'number of bits invalid for bit field')) self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
def test_multi_bitfields_size(self): def test_multi_bitfields_size(self):
class X(Structure): class X(Structure):
_fields_ = [("a", c_short, 1), _fields_ = [("a", c_short, 1),
("b", c_short, 14), ("b", c_short, 14),
("c", c_short, 1)] ("c", c_short, 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_short)) self.assertEqual(sizeof(X), sizeof(c_short))
class X(Structure): class X(Structure):
_fields_ = [("a", c_short, 1), _fields_ = [("a", c_short, 1),
("a1", c_short), ("a1", c_short),
("b", c_short, 14), ("b", c_short, 14),
("c", c_short, 1)] ("c", c_short, 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_short)*3) self.assertEqual(sizeof(X), sizeof(c_short)*3)
self.failUnlessEqual(X.a.offset, 0) self.assertEqual(X.a.offset, 0)
self.failUnlessEqual(X.a1.offset, sizeof(c_short)) self.assertEqual(X.a1.offset, sizeof(c_short))
self.failUnlessEqual(X.b.offset, sizeof(c_short)*2) self.assertEqual(X.b.offset, sizeof(c_short)*2)
self.failUnlessEqual(X.c.offset, sizeof(c_short)*2) self.assertEqual(X.c.offset, sizeof(c_short)*2)
class X(Structure): class X(Structure):
_fields_ = [("a", c_short, 3), _fields_ = [("a", c_short, 3),
("b", c_short, 14), ("b", c_short, 14),
("c", c_short, 14)] ("c", c_short, 14)]
self.failUnlessEqual(sizeof(X), sizeof(c_short)*3) self.assertEqual(sizeof(X), sizeof(c_short)*3)
self.failUnlessEqual(X.a.offset, sizeof(c_short)*0) self.assertEqual(X.a.offset, sizeof(c_short)*0)
self.failUnlessEqual(X.b.offset, sizeof(c_short)*1) self.assertEqual(X.b.offset, sizeof(c_short)*1)
self.failUnlessEqual(X.c.offset, sizeof(c_short)*2) self.assertEqual(X.c.offset, sizeof(c_short)*2)
def get_except(self, func, *args, **kw): def get_except(self, func, *args, **kw):
@ -199,21 +199,21 @@ class X(Structure):
_fields_ = [("a", c_byte, 4), _fields_ = [("a", c_byte, 4),
("b", c_int, 4)] ("b", c_int, 4)]
if os.name in ("nt", "ce"): if os.name in ("nt", "ce"):
self.failUnlessEqual(sizeof(X), sizeof(c_int)*2) self.assertEqual(sizeof(X), sizeof(c_int)*2)
else: else:
self.failUnlessEqual(sizeof(X), sizeof(c_int)) self.assertEqual(sizeof(X), sizeof(c_int))
def test_mixed_2(self): def test_mixed_2(self):
class X(Structure): class X(Structure):
_fields_ = [("a", c_byte, 4), _fields_ = [("a", c_byte, 4),
("b", c_int, 32)] ("b", c_int, 32)]
self.failUnlessEqual(sizeof(X), sizeof(c_int)*2) self.assertEqual(sizeof(X), sizeof(c_int)*2)
def test_mixed_3(self): def test_mixed_3(self):
class X(Structure): class X(Structure):
_fields_ = [("a", c_byte, 4), _fields_ = [("a", c_byte, 4),
("b", c_ubyte, 4)] ("b", c_ubyte, 4)]
self.failUnlessEqual(sizeof(X), sizeof(c_byte)) self.assertEqual(sizeof(X), sizeof(c_byte))
def test_mixed_4(self): def test_mixed_4(self):
class X(Structure): class X(Structure):
@ -227,9 +227,9 @@ class X(Structure):
# does (unless GCC is run with '-mms-bitfields' which # does (unless GCC is run with '-mms-bitfields' which
# produces code compatible with MSVC). # produces code compatible with MSVC).
if os.name in ("nt", "ce"): if os.name in ("nt", "ce"):
self.failUnlessEqual(sizeof(X), sizeof(c_int) * 4) self.assertEqual(sizeof(X), sizeof(c_int) * 4)
else: else:
self.failUnlessEqual(sizeof(X), sizeof(c_int) * 2) self.assertEqual(sizeof(X), sizeof(c_int) * 2)
def test_anon_bitfields(self): def test_anon_bitfields(self):
# anonymous bit-fields gave a strange error message # anonymous bit-fields gave a strange error message

84
Lib/ctypes/test/test_buffers.py
View file

@ -5,32 +5,32 @@ class StringBufferTestCase(unittest.TestCase):
def test_buffer(self): def test_buffer(self):
b = create_string_buffer(32) b = create_string_buffer(32)
self.failUnlessEqual(len(b), 32) self.assertEqual(len(b), 32)
self.failUnlessEqual(sizeof(b), 32 * sizeof(c_char)) self.assertEqual(sizeof(b), 32 * sizeof(c_char))
self.failUnless(type(b[0]) is bytes) self.assertTrue(type(b[0]) is bytes)
b = create_string_buffer("abc") b = create_string_buffer("abc")
self.failUnlessEqual(len(b), 4) # trailing nul char self.assertEqual(len(b), 4) # trailing nul char
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char)) self.assertEqual(sizeof(b), 4 * sizeof(c_char))
self.failUnless(type(b[0]) is bytes) self.assertTrue(type(b[0]) is bytes)
self.failUnlessEqual(b[0], b"a") self.assertEqual(b[0], b"a")
self.failUnlessEqual(b[:], b"abc\0") self.assertEqual(b[:], b"abc\0")
self.failUnlessEqual(b[::], b"abc\0") self.assertEqual(b[::], b"abc\0")
self.failUnlessEqual(b[::-1], b"\0cba") self.assertEqual(b[::-1], b"\0cba")
self.failUnlessEqual(b[::2], b"ac") self.assertEqual(b[::2], b"ac")
self.failUnlessEqual(b[::5], b"a") self.assertEqual(b[::5], b"a")
def test_string_conversion(self): def test_string_conversion(self):
b = create_string_buffer("abc") b = create_string_buffer("abc")
self.failUnlessEqual(len(b), 4) # trailing nul char self.assertEqual(len(b), 4) # trailing nul char
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char)) self.assertEqual(sizeof(b), 4 * sizeof(c_char))
self.failUnless(type(b[0]) is bytes) self.assertTrue(type(b[0]) is bytes)
self.failUnlessEqual(b[0], b"a") self.assertEqual(b[0], b"a")
self.failUnlessEqual(b[:], b"abc\0") self.assertEqual(b[:], b"abc\0")
self.failUnlessEqual(b[::], b"abc\0") self.assertEqual(b[::], b"abc\0")
self.failUnlessEqual(b[::-1], b"\0cba") self.assertEqual(b[::-1], b"\0cba")
self.failUnlessEqual(b[::2], b"ac") self.assertEqual(b[::2], b"ac")
self.failUnlessEqual(b[::5], b"a") self.assertEqual(b[::5], b"a")
try: try:
c_wchar c_wchar
@ -39,32 +39,32 @@ def test_string_conversion(self):
else: else:
def test_unicode_buffer(self): def test_unicode_buffer(self):
b = create_unicode_buffer(32) b = create_unicode_buffer(32)
self.failUnlessEqual(len(b), 32) self.assertEqual(len(b), 32)
self.failUnlessEqual(sizeof(b), 32 * sizeof(c_wchar)) self.assertEqual(sizeof(b), 32 * sizeof(c_wchar))
self.failUnless(type(b[0]) is str) self.assertTrue(type(b[0]) is str)
b = create_unicode_buffer("abc") b = create_unicode_buffer("abc")
self.failUnlessEqual(len(b), 4) # trailing nul char self.assertEqual(len(b), 4) # trailing nul char
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_wchar)) self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
self.failUnless(type(b[0]) is str) self.assertTrue(type(b[0]) is str)
self.failUnlessEqual(b[0], "a") self.assertEqual(b[0], "a")
self.failUnlessEqual(b[:], "abc\0") self.assertEqual(b[:], "abc\0")
self.failUnlessEqual(b[::], "abc\0") self.assertEqual(b[::], "abc\0")
self.failUnlessEqual(b[::-1], "\0cba") self.assertEqual(b[::-1], "\0cba")
self.failUnlessEqual(b[::2], "ac") self.assertEqual(b[::2], "ac")
self.failUnlessEqual(b[::5], "a") self.assertEqual(b[::5], "a")
def test_unicode_conversion(self): def test_unicode_conversion(self):
b = create_unicode_buffer("abc") b = create_unicode_buffer("abc")
self.failUnlessEqual(len(b), 4) # trailing nul char self.assertEqual(len(b), 4) # trailing nul char
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_wchar)) self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
self.failUnless(type(b[0]) is str) self.assertTrue(type(b[0]) is str)
self.failUnlessEqual(b[0], "a") self.assertEqual(b[0], "a")
self.failUnlessEqual(b[:], "abc\0") self.assertEqual(b[:], "abc\0")
self.failUnlessEqual(b[::], "abc\0") self.assertEqual(b[::], "abc\0")
self.failUnlessEqual(b[::-1], "\0cba") self.assertEqual(b[::-1], "\0cba")
self.failUnlessEqual(b[::2], "ac") self.assertEqual(b[::2], "ac")
self.failUnlessEqual(b[::5], "a") self.assertEqual(b[::5], "a")
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

154
Lib/ctypes/test/test_byteswap.py
View file

@ -23,131 +23,131 @@ def X_test(self):
def test_endian_short(self): def test_endian_short(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.failUnless(c_short.__ctype_le__ is c_short) self.assertTrue(c_short.__ctype_le__ is c_short)
self.failUnless(c_short.__ctype_be__.__ctype_le__ is c_short) self.assertTrue(c_short.__ctype_be__.__ctype_le__ is c_short)
else: else:
self.failUnless(c_short.__ctype_be__ is c_short) self.assertTrue(c_short.__ctype_be__ is c_short)
self.failUnless(c_short.__ctype_le__.__ctype_be__ is c_short) self.assertTrue(c_short.__ctype_le__.__ctype_be__ is c_short)
s = c_short.__ctype_be__(0x1234) s = c_short.__ctype_be__(0x1234)
self.failUnlessEqual(bin(struct.pack(">h", 0x1234)), "1234") self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
self.failUnlessEqual(bin(s), "1234") self.assertEqual(bin(s), "1234")
self.failUnlessEqual(s.value, 0x1234) self.assertEqual(s.value, 0x1234)
s = c_short.__ctype_le__(0x1234) s = c_short.__ctype_le__(0x1234)
self.failUnlessEqual(bin(struct.pack("<h", 0x1234)), "3412") self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
self.failUnlessEqual(bin(s), "3412") self.assertEqual(bin(s), "3412")
self.failUnlessEqual(s.value, 0x1234) self.assertEqual(s.value, 0x1234)
s = c_ushort.__ctype_be__(0x1234) s = c_ushort.__ctype_be__(0x1234)
self.failUnlessEqual(bin(struct.pack(">h", 0x1234)), "1234") self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
self.failUnlessEqual(bin(s), "1234") self.assertEqual(bin(s), "1234")
self.failUnlessEqual(s.value, 0x1234) self.assertEqual(s.value, 0x1234)
s = c_ushort.__ctype_le__(0x1234) s = c_ushort.__ctype_le__(0x1234)
self.failUnlessEqual(bin(struct.pack("<h", 0x1234)), "3412") self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
self.failUnlessEqual(bin(s), "3412") self.assertEqual(bin(s), "3412")
self.failUnlessEqual(s.value, 0x1234) self.assertEqual(s.value, 0x1234)
def test_endian_int(self): def test_endian_int(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.failUnless(c_int.__ctype_le__ is c_int) self.assertTrue(c_int.__ctype_le__ is c_int)
self.failUnless(c_int.__ctype_be__.__ctype_le__ is c_int) self.assertTrue(c_int.__ctype_be__.__ctype_le__ is c_int)
else: else:
self.failUnless(c_int.__ctype_be__ is c_int) self.assertTrue(c_int.__ctype_be__ is c_int)
self.failUnless(c_int.__ctype_le__.__ctype_be__ is c_int) self.assertTrue(c_int.__ctype_le__.__ctype_be__ is c_int)
s = c_int.__ctype_be__(0x12345678) s = c_int.__ctype_be__(0x12345678)
self.failUnlessEqual(bin(struct.pack(">i", 0x12345678)), "12345678") self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
self.failUnlessEqual(bin(s), "12345678") self.assertEqual(bin(s), "12345678")
self.failUnlessEqual(s.value, 0x12345678) self.assertEqual(s.value, 0x12345678)
s = c_int.__ctype_le__(0x12345678) s = c_int.__ctype_le__(0x12345678)
self.failUnlessEqual(bin(struct.pack("<i", 0x12345678)), "78563412") self.assertEqual(bin(struct.pack("<i", 0x12345678)), "78563412")
self.failUnlessEqual(bin(s), "78563412") self.assertEqual(bin(s), "78563412")
self.failUnlessEqual(s.value, 0x12345678) self.assertEqual(s.value, 0x12345678)
s = c_uint.__ctype_be__(0x12345678) s = c_uint.__ctype_be__(0x12345678)
self.failUnlessEqual(bin(struct.pack(">I", 0x12345678)), "12345678") self.assertEqual(bin(struct.pack(">I", 0x12345678)), "12345678")
self.failUnlessEqual(bin(s), "12345678") self.assertEqual(bin(s), "12345678")
self.failUnlessEqual(s.value, 0x12345678) self.assertEqual(s.value, 0x12345678)
s = c_uint.__ctype_le__(0x12345678) s = c_uint.__ctype_le__(0x12345678)
self.failUnlessEqual(bin(struct.pack("<I", 0x12345678)), "78563412") self.assertEqual(bin(struct.pack("<I", 0x12345678)), "78563412")
self.failUnlessEqual(bin(s), "78563412") self.assertEqual(bin(s), "78563412")
self.failUnlessEqual(s.value, 0x12345678) self.assertEqual(s.value, 0x12345678)
def test_endian_longlong(self): def test_endian_longlong(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.failUnless(c_longlong.__ctype_le__ is c_longlong) self.assertTrue(c_longlong.__ctype_le__ is c_longlong)
self.failUnless(c_longlong.__ctype_be__.__ctype_le__ is c_longlong) self.assertTrue(c_longlong.__ctype_be__.__ctype_le__ is c_longlong)
else: else:
self.failUnless(c_longlong.__ctype_be__ is c_longlong) self.assertTrue(c_longlong.__ctype_be__ is c_longlong)
self.failUnless(c_longlong.__ctype_le__.__ctype_be__ is c_longlong) self.assertTrue(c_longlong.__ctype_le__.__ctype_be__ is c_longlong)
s = c_longlong.__ctype_be__(0x1234567890ABCDEF) s = c_longlong.__ctype_be__(0x1234567890ABCDEF)
self.failUnlessEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF") self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
self.failUnlessEqual(bin(s), "1234567890ABCDEF") self.assertEqual(bin(s), "1234567890ABCDEF")
self.failUnlessEqual(s.value, 0x1234567890ABCDEF) self.assertEqual(s.value, 0x1234567890ABCDEF)
s = c_longlong.__ctype_le__(0x1234567890ABCDEF) s = c_longlong.__ctype_le__(0x1234567890ABCDEF)
self.failUnlessEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412") self.assertEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
self.failUnlessEqual(bin(s), "EFCDAB9078563412") self.assertEqual(bin(s), "EFCDAB9078563412")
self.failUnlessEqual(s.value, 0x1234567890ABCDEF) self.assertEqual(s.value, 0x1234567890ABCDEF)
s = c_ulonglong.__ctype_be__(0x1234567890ABCDEF) s = c_ulonglong.__ctype_be__(0x1234567890ABCDEF)
self.failUnlessEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF") self.assertEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
self.failUnlessEqual(bin(s), "1234567890ABCDEF") self.assertEqual(bin(s), "1234567890ABCDEF")
self.failUnlessEqual(s.value, 0x1234567890ABCDEF) self.assertEqual(s.value, 0x1234567890ABCDEF)
s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF) s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF)
self.failUnlessEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412") self.assertEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
self.failUnlessEqual(bin(s), "EFCDAB9078563412") self.assertEqual(bin(s), "EFCDAB9078563412")
self.failUnlessEqual(s.value, 0x1234567890ABCDEF) self.assertEqual(s.value, 0x1234567890ABCDEF)
def test_endian_float(self): def test_endian_float(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.failUnless(c_float.__ctype_le__ is c_float) self.assertTrue(c_float.__ctype_le__ is c_float)
self.failUnless(c_float.__ctype_be__.__ctype_le__ is c_float) self.assertTrue(c_float.__ctype_be__.__ctype_le__ is c_float)
else: else:
self.failUnless(c_float.__ctype_be__ is c_float) self.assertTrue(c_float.__ctype_be__ is c_float)
self.failUnless(c_float.__ctype_le__.__ctype_be__ is c_float) self.assertTrue(c_float.__ctype_le__.__ctype_be__ is c_float)
s = c_float(math.pi) s = c_float(math.pi)
self.failUnlessEqual(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?
self.failUnlessAlmostEqual(s.value, math.pi, places=6) self.assertAlmostEqual(s.value, math.pi, places=6)
s = c_float.__ctype_le__(math.pi) s = c_float.__ctype_le__(math.pi)
self.failUnlessAlmostEqual(s.value, math.pi, places=6) self.assertAlmostEqual(s.value, math.pi, places=6)
self.failUnlessEqual(bin(struct.pack("<f", math.pi)), bin(s)) self.assertEqual(bin(struct.pack("<f", math.pi)), bin(s))
s = c_float.__ctype_be__(math.pi) s = c_float.__ctype_be__(math.pi)
self.failUnlessAlmostEqual(s.value, math.pi, places=6) self.assertAlmostEqual(s.value, math.pi, places=6)
self.failUnlessEqual(bin(struct.pack(">f", math.pi)), bin(s)) self.assertEqual(bin(struct.pack(">f", math.pi)), bin(s))
def test_endian_double(self): def test_endian_double(self):
if sys.byteorder == "little": if sys.byteorder == "little":
self.failUnless(c_double.__ctype_le__ is c_double) self.assertTrue(c_double.__ctype_le__ is c_double)
self.failUnless(c_double.__ctype_be__.__ctype_le__ is c_double) self.assertTrue(c_double.__ctype_be__.__ctype_le__ is c_double)
else: else:
self.failUnless(c_double.__ctype_be__ is c_double) self.assertTrue(c_double.__ctype_be__ is c_double)
self.failUnless(c_double.__ctype_le__.__ctype_be__ is c_double) self.assertTrue(c_double.__ctype_le__.__ctype_be__ is c_double)
s = c_double(math.pi) s = c_double(math.pi)
self.failUnlessEqual(s.value, math.pi) self.assertEqual(s.value, math.pi)
self.failUnlessEqual(bin(struct.pack("d", math.pi)), bin(s)) self.assertEqual(bin(struct.pack("d", math.pi)), bin(s))
s = c_double.__ctype_le__(math.pi) s = c_double.__ctype_le__(math.pi)
self.failUnlessEqual(s.value, math.pi) self.assertEqual(s.value, math.pi)
self.failUnlessEqual(bin(struct.pack("<d", math.pi)), bin(s)) self.assertEqual(bin(struct.pack("<d", math.pi)), bin(s))
s = c_double.__ctype_be__(math.pi) s = c_double.__ctype_be__(math.pi)
self.failUnlessEqual(s.value, math.pi) self.assertEqual(s.value, math.pi)
self.failUnlessEqual(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.failUnless(c_byte.__ctype_le__ is c_byte) self.assertTrue(c_byte.__ctype_le__ is c_byte)
self.failUnless(c_byte.__ctype_be__ is c_byte) self.assertTrue(c_byte.__ctype_be__ is c_byte)
self.failUnless(c_ubyte.__ctype_le__ is c_ubyte) self.assertTrue(c_ubyte.__ctype_le__ is c_ubyte)
self.failUnless(c_ubyte.__ctype_be__ is c_ubyte) self.assertTrue(c_ubyte.__ctype_be__ is c_ubyte)
self.failUnless(c_char.__ctype_le__ is c_char) self.assertTrue(c_char.__ctype_le__ is c_char)
self.failUnless(c_char.__ctype_be__ is c_char) self.assertTrue(c_char.__ctype_be__ is c_char)
def test_struct_fields_1(self): def test_struct_fields_1(self):
if sys.byteorder == "little": if sys.byteorder == "little":
@ -219,7 +219,7 @@ class S(base):
s1 = S(0x12, 0x1234, 0x12345678, 3.14) s1 = S(0x12, 0x1234, 0x12345678, 3.14)
s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14) s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
self.failUnlessEqual(bin(s1), bin(s2)) self.assertEqual(bin(s1), bin(s2))
def test_unaligned_nonnative_struct_fields(self): def test_unaligned_nonnative_struct_fields(self):
if sys.byteorder == "little": if sys.byteorder == "little":
@ -247,7 +247,7 @@ class S(base):
s1.i = 0x12345678 s1.i = 0x12345678
s1.d = 3.14 s1.d = 3.14
s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14) s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
self.failUnlessEqual(bin(s1), bin(s2)) self.assertEqual(bin(s1), bin(s2))
def test_unaligned_native_struct_fields(self): def test_unaligned_native_struct_fields(self):
if sys.byteorder == "little": if sys.byteorder == "little":
@ -274,7 +274,7 @@ class S(Structure):
s1.i = 0x12345678 s1.i = 0x12345678
s1.d = 3.14 s1.d = 3.14
s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14) s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
self.failUnlessEqual(bin(s1), bin(s2)) self.assertEqual(bin(s1), bin(s2))
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

16
Lib/ctypes/test/test_callbacks.py
View file

@ -17,18 +17,18 @@ def check_type(self, typ, arg):
PROTO = self.functype.__func__(typ, typ) PROTO = self.functype.__func__(typ, typ)
result = PROTO(self.callback)(arg) result = PROTO(self.callback)(arg)
if typ == c_float: if typ == c_float:
self.failUnlessAlmostEqual(result, arg, places=5) self.assertAlmostEqual(result, arg, places=5)
else: else:
self.failUnlessEqual(self.got_args, (arg,)) self.assertEqual(self.got_args, (arg,))
self.failUnlessEqual(result, arg) self.assertEqual(result, arg)
PROTO = self.functype.__func__(typ, c_byte, typ) PROTO = self.functype.__func__(typ, c_byte, typ)
result = PROTO(self.callback)(-3, arg) result = PROTO(self.callback)(-3, arg)
if typ == c_float: if typ == c_float:
self.failUnlessAlmostEqual(result, arg, places=5) self.assertAlmostEqual(result, arg, places=5)
else: else:
self.failUnlessEqual(self.got_args, (-3, arg)) self.assertEqual(self.got_args, (-3, arg))
self.failUnlessEqual(result, arg) self.assertEqual(result, arg)
################ ################
@ -103,7 +103,7 @@ def test_pyobject(self):
# ...but this call doesn't leak any more. Where is the refcount? # ...but this call doesn't leak any more. Where is the refcount?
self.check_type(py_object, o) self.check_type(py_object, o)
after = grc(o) after = grc(o)
self.failUnlessEqual((after, o), (before, o)) self.assertEqual((after, o), (before, o))
def test_unsupported_restype_1(self): def test_unsupported_restype_1(self):
# Only "fundamental" result types are supported for callback # Only "fundamental" result types are supported for callback
@ -148,7 +148,7 @@ def func(x):
result = integrate(0.0, 1.0, CALLBACK(func), 10) result = integrate(0.0, 1.0, CALLBACK(func), 10)
diff = abs(result - 1./3.) diff = abs(result - 1./3.)
self.failUnless(diff < 0.01, "%s not less than 0.01" % diff) self.assertTrue(diff < 0.01, "%s not less than 0.01" % diff)
################################################################ ################################################################

62
Lib/ctypes/test/test_cast.py
View file

@ -9,15 +9,15 @@ def test_array2pointer(self):
# casting an array to a pointer works. # casting an array to a pointer works.
ptr = cast(array, POINTER(c_int)) ptr = cast(array, POINTER(c_int))
self.failUnlessEqual([ptr[i] for i in range(3)], [42, 17, 2]) self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
if 2*sizeof(c_short) == sizeof(c_int): if 2*sizeof(c_short) == sizeof(c_int):
ptr = cast(array, POINTER(c_short)) ptr = cast(array, POINTER(c_short))
if sys.byteorder == "little": if sys.byteorder == "little":
self.failUnlessEqual([ptr[i] for i in range(6)], self.assertEqual([ptr[i] for i in range(6)],
[42, 0, 17, 0, 2, 0]) [42, 0, 17, 0, 2, 0])
else: else:
self.failUnlessEqual([ptr[i] for i in range(6)], self.assertEqual([ptr[i] for i in range(6)],
[0, 42, 0, 17, 0, 2]) [0, 42, 0, 17, 0, 2])
def test_address2pointer(self): def test_address2pointer(self):
@ -25,54 +25,54 @@ def test_address2pointer(self):
address = addressof(array) address = addressof(array)
ptr = cast(c_void_p(address), POINTER(c_int)) ptr = cast(c_void_p(address), POINTER(c_int))
self.failUnlessEqual([ptr[i] for i in range(3)], [42, 17, 2]) self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
ptr = cast(address, POINTER(c_int)) ptr = cast(address, POINTER(c_int))
self.failUnlessEqual([ptr[i] for i in range(3)], [42, 17, 2]) self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
def test_p2a_objects(self): def test_p2a_objects(self):
array = (c_char_p * 5)() array = (c_char_p * 5)()
self.failUnlessEqual(array._objects, None) self.assertEqual(array._objects, None)
array[0] = "foo bar" array[0] = "foo bar"
self.failUnlessEqual(array._objects, {'0': b"foo bar"}) self.assertEqual(array._objects, {'0': b"foo bar"})
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.failUnless(p._objects is array._objects) self.assertTrue(p._objects is array._objects)
self.failUnlessEqual(array._objects, {'0': b"foo bar", id(array): array}) self.assertEqual(array._objects, {'0': b"foo bar", id(array): array})
p[0] = "spam spam" p[0] = "spam spam"
self.failUnlessEqual(p._objects, {'0': b"spam spam", id(array): array}) self.assertEqual(p._objects, {'0': b"spam spam", id(array): array})
self.failUnless(array._objects is p._objects) self.assertTrue(array._objects is p._objects)
p[1] = "foo bar" p[1] = "foo bar"
self.failUnlessEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array}) self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array})
self.failUnless(array._objects is p._objects) self.assertTrue(array._objects is 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))
self.failUnlessEqual(p[:4], [1,2, 3, 4]) self.assertEqual(p[:4], [1,2, 3, 4])
self.failUnlessEqual(p[:4:], [1, 2, 3, 4]) self.assertEqual(p[:4:], [1, 2, 3, 4])
self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1]) self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
self.failUnlessEqual(p[:4:3], [1, 4]) self.assertEqual(p[:4:3], [1, 4])
c_int() c_int()
self.failUnlessEqual(p[:4], [1, 2, 3, 4]) self.assertEqual(p[:4], [1, 2, 3, 4])
self.failUnlessEqual(p[:4:], [1, 2, 3, 4]) self.assertEqual(p[:4:], [1, 2, 3, 4])
self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1]) self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
self.failUnlessEqual(p[:4:3], [1, 4]) self.assertEqual(p[:4:3], [1, 4])
p[2] = 96 p[2] = 96
self.failUnlessEqual(p[:4], [1, 2, 96, 4]) self.assertEqual(p[:4], [1, 2, 96, 4])
self.failUnlessEqual(p[:4:], [1, 2, 96, 4]) self.assertEqual(p[:4:], [1, 2, 96, 4])
self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1]) self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
self.failUnlessEqual(p[:4:3], [1, 4]) self.assertEqual(p[:4:3], [1, 4])
c_int() c_int()
self.failUnlessEqual(p[:4], [1, 2, 96, 4]) self.assertEqual(p[:4], [1, 2, 96, 4])
self.failUnlessEqual(p[:4:], [1, 2, 96, 4]) self.assertEqual(p[:4:], [1, 2, 96, 4])
self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1]) self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
self.failUnlessEqual(p[:4:3], [1, 4]) self.assertEqual(p[:4:3], [1, 4])
def test_char_p(self): def test_char_p(self):
# This didn't work: bad argument to internal function # This didn't work: bad argument to internal function
s = c_char_p("hiho") s = c_char_p("hiho")
self.failUnlessEqual(cast(cast(s, c_void_p), c_char_p).value, self.assertEqual(cast(cast(s, c_void_p), c_char_p).value,
"hiho") "hiho")
try: try:
@ -82,7 +82,7 @@ def test_char_p(self):
else: else:
def test_wchar_p(self): def test_wchar_p(self):
s = c_wchar_p("hiho") s = c_wchar_p("hiho")
self.failUnlessEqual(cast(cast(s, c_void_p), c_wchar_p).value, self.assertEqual(cast(cast(s, c_void_p), c_wchar_p).value,
"hiho") "hiho")
if __name__ == "__main__": if __name__ == "__main__":

120
Lib/ctypes/test/test_cfuncs.py
View file

@ -17,176 +17,176 @@ def U(self):
def test_byte(self): def test_byte(self):
self._dll.tf_b.restype = c_byte self._dll.tf_b.restype = c_byte
self._dll.tf_b.argtypes = (c_byte,) self._dll.tf_b.argtypes = (c_byte,)
self.failUnlessEqual(self._dll.tf_b(-126), -42) self.assertEqual(self._dll.tf_b(-126), -42)
self.failUnlessEqual(self.S(), -126) self.assertEqual(self.S(), -126)
def test_byte_plus(self): def test_byte_plus(self):
self._dll.tf_bb.restype = c_byte self._dll.tf_bb.restype = c_byte
self._dll.tf_bb.argtypes = (c_byte, c_byte) self._dll.tf_bb.argtypes = (c_byte, c_byte)
self.failUnlessEqual(self._dll.tf_bb(0, -126), -42) self.assertEqual(self._dll.tf_bb(0, -126), -42)
self.failUnlessEqual(self.S(), -126) self.assertEqual(self.S(), -126)
def test_ubyte(self): def test_ubyte(self):
self._dll.tf_B.restype = c_ubyte self._dll.tf_B.restype = c_ubyte
self._dll.tf_B.argtypes = (c_ubyte,) self._dll.tf_B.argtypes = (c_ubyte,)
self.failUnlessEqual(self._dll.tf_B(255), 85) self.assertEqual(self._dll.tf_B(255), 85)
self.failUnlessEqual(self.U(), 255) self.assertEqual(self.U(), 255)
def test_ubyte_plus(self): def test_ubyte_plus(self):
self._dll.tf_bB.restype = c_ubyte self._dll.tf_bB.restype = c_ubyte
self._dll.tf_bB.argtypes = (c_byte, c_ubyte) self._dll.tf_bB.argtypes = (c_byte, c_ubyte)
self.failUnlessEqual(self._dll.tf_bB(0, 255), 85) self.assertEqual(self._dll.tf_bB(0, 255), 85)
self.failUnlessEqual(self.U(), 255) self.assertEqual(self.U(), 255)
def test_short(self): def test_short(self):
self._dll.tf_h.restype = c_short self._dll.tf_h.restype = c_short
self._dll.tf_h.argtypes = (c_short,) self._dll.tf_h.argtypes = (c_short,)
self.failUnlessEqual(self._dll.tf_h(-32766), -10922) self.assertEqual(self._dll.tf_h(-32766), -10922)
self.failUnlessEqual(self.S(), -32766) self.assertEqual(self.S(), -32766)
def test_short_plus(self): def test_short_plus(self):
self._dll.tf_bh.restype = c_short self._dll.tf_bh.restype = c_short
self._dll.tf_bh.argtypes = (c_byte, c_short) self._dll.tf_bh.argtypes = (c_byte, c_short)
self.failUnlessEqual(self._dll.tf_bh(0, -32766), -10922) self.assertEqual(self._dll.tf_bh(0, -32766), -10922)
self.failUnlessEqual(self.S(), -32766) self.assertEqual(self.S(), -32766)
def test_ushort(self): def test_ushort(self):
self._dll.tf_H.restype = c_ushort self._dll.tf_H.restype = c_ushort
self._dll.tf_H.argtypes = (c_ushort,) self._dll.tf_H.argtypes = (c_ushort,)
self.failUnlessEqual(self._dll.tf_H(65535), 21845) self.assertEqual(self._dll.tf_H(65535), 21845)
self.failUnlessEqual(self.U(), 65535) self.assertEqual(self.U(), 65535)
def test_ushort_plus(self): def test_ushort_plus(self):
self._dll.tf_bH.restype = c_ushort self._dll.tf_bH.restype = c_ushort
self._dll.tf_bH.argtypes = (c_byte, c_ushort) self._dll.tf_bH.argtypes = (c_byte, c_ushort)
self.failUnlessEqual(self._dll.tf_bH(0, 65535), 21845) self.assertEqual(self._dll.tf_bH(0, 65535), 21845)
self.failUnlessEqual(self.U(), 65535) self.assertEqual(self.U(), 65535)
def test_int(self): def test_int(self):
self._dll.tf_i.restype = c_int self._dll.tf_i.restype = c_int
self._dll.tf_i.argtypes = (c_int,) self._dll.tf_i.argtypes = (c_int,)
self.failUnlessEqual(self._dll.tf_i(-2147483646), -715827882) self.assertEqual(self._dll.tf_i(-2147483646), -715827882)
self.failUnlessEqual(self.S(), -2147483646) self.assertEqual(self.S(), -2147483646)
def test_int_plus(self): def test_int_plus(self):
self._dll.tf_bi.restype = c_int self._dll.tf_bi.restype = c_int
self._dll.tf_bi.argtypes = (c_byte, c_int) self._dll.tf_bi.argtypes = (c_byte, c_int)
self.failUnlessEqual(self._dll.tf_bi(0, -2147483646), -715827882) self.assertEqual(self._dll.tf_bi(0, -2147483646), -715827882)
self.failUnlessEqual(self.S(), -2147483646) self.assertEqual(self.S(), -2147483646)
def test_uint(self): def test_uint(self):
self._dll.tf_I.restype = c_uint self._dll.tf_I.restype = c_uint
self._dll.tf_I.argtypes = (c_uint,) self._dll.tf_I.argtypes = (c_uint,)
self.failUnlessEqual(self._dll.tf_I(4294967295), 1431655765) self.assertEqual(self._dll.tf_I(4294967295), 1431655765)
self.failUnlessEqual(self.U(), 4294967295) self.assertEqual(self.U(), 4294967295)
def test_uint_plus(self): def test_uint_plus(self):
self._dll.tf_bI.restype = c_uint self._dll.tf_bI.restype = c_uint
self._dll.tf_bI.argtypes = (c_byte, c_uint) self._dll.tf_bI.argtypes = (c_byte, c_uint)
self.failUnlessEqual(self._dll.tf_bI(0, 4294967295), 1431655765) self.assertEqual(self._dll.tf_bI(0, 4294967295), 1431655765)
self.failUnlessEqual(self.U(), 4294967295) self.assertEqual(self.U(), 4294967295)
def test_long(self): def test_long(self):
self._dll.tf_l.restype = c_long self._dll.tf_l.restype = c_long
self._dll.tf_l.argtypes = (c_long,) self._dll.tf_l.argtypes = (c_long,)
self.failUnlessEqual(self._dll.tf_l(-2147483646), -715827882) self.assertEqual(self._dll.tf_l(-2147483646), -715827882)
self.failUnlessEqual(self.S(), -2147483646) self.assertEqual(self.S(), -2147483646)
def test_long_plus(self): def test_long_plus(self):
self._dll.tf_bl.restype = c_long self._dll.tf_bl.restype = c_long
self._dll.tf_bl.argtypes = (c_byte, c_long) self._dll.tf_bl.argtypes = (c_byte, c_long)
self.failUnlessEqual(self._dll.tf_bl(0, -2147483646), -715827882) self.assertEqual(self._dll.tf_bl(0, -2147483646), -715827882)
self.failUnlessEqual(self.S(), -2147483646) self.assertEqual(self.S(), -2147483646)
def test_ulong(self): def test_ulong(self):
self._dll.tf_L.restype = c_ulong self._dll.tf_L.restype = c_ulong
self._dll.tf_L.argtypes = (c_ulong,) self._dll.tf_L.argtypes = (c_ulong,)
self.failUnlessEqual(self._dll.tf_L(4294967295), 1431655765) self.assertEqual(self._dll.tf_L(4294967295), 1431655765)
self.failUnlessEqual(self.U(), 4294967295) self.assertEqual(self.U(), 4294967295)
def test_ulong_plus(self): def test_ulong_plus(self):
self._dll.tf_bL.restype = c_ulong self._dll.tf_bL.restype = c_ulong
self._dll.tf_bL.argtypes = (c_char, c_ulong) self._dll.tf_bL.argtypes = (c_char, c_ulong)
self.failUnlessEqual(self._dll.tf_bL(' ', 4294967295), 1431655765) self.assertEqual(self._dll.tf_bL(' ', 4294967295), 1431655765)
self.failUnlessEqual(self.U(), 4294967295) self.assertEqual(self.U(), 4294967295)
def test_longlong(self): def test_longlong(self):
self._dll.tf_q.restype = c_longlong self._dll.tf_q.restype = c_longlong
self._dll.tf_q.argtypes = (c_longlong, ) self._dll.tf_q.argtypes = (c_longlong, )
self.failUnlessEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602) self.assertEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602)
self.failUnlessEqual(self.S(), -9223372036854775806) self.assertEqual(self.S(), -9223372036854775806)
def test_longlong_plus(self): def test_longlong_plus(self):
self._dll.tf_bq.restype = c_longlong self._dll.tf_bq.restype = c_longlong
self._dll.tf_bq.argtypes = (c_byte, c_longlong) self._dll.tf_bq.argtypes = (c_byte, c_longlong)
self.failUnlessEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602) self.assertEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602)
self.failUnlessEqual(self.S(), -9223372036854775806) self.assertEqual(self.S(), -9223372036854775806)
def test_ulonglong(self): def test_ulonglong(self):
self._dll.tf_Q.restype = c_ulonglong self._dll.tf_Q.restype = c_ulonglong
self._dll.tf_Q.argtypes = (c_ulonglong, ) self._dll.tf_Q.argtypes = (c_ulonglong, )
self.failUnlessEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205) self.assertEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205)
self.failUnlessEqual(self.U(), 18446744073709551615) self.assertEqual(self.U(), 18446744073709551615)
def test_ulonglong_plus(self): def test_ulonglong_plus(self):
self._dll.tf_bQ.restype = c_ulonglong self._dll.tf_bQ.restype = c_ulonglong
self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong) self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong)
self.failUnlessEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205) self.assertEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205)
self.failUnlessEqual(self.U(), 18446744073709551615) self.assertEqual(self.U(), 18446744073709551615)
def test_float(self): def test_float(self):
self._dll.tf_f.restype = c_float self._dll.tf_f.restype = c_float
self._dll.tf_f.argtypes = (c_float,) self._dll.tf_f.argtypes = (c_float,)
self.failUnlessEqual(self._dll.tf_f(-42.), -14.) self.assertEqual(self._dll.tf_f(-42.), -14.)
self.failUnlessEqual(self.S(), -42) self.assertEqual(self.S(), -42)
def test_float_plus(self): def test_float_plus(self):
self._dll.tf_bf.restype = c_float self._dll.tf_bf.restype = c_float
self._dll.tf_bf.argtypes = (c_byte, c_float) self._dll.tf_bf.argtypes = (c_byte, c_float)
self.failUnlessEqual(self._dll.tf_bf(0, -42.), -14.) self.assertEqual(self._dll.tf_bf(0, -42.), -14.)
self.failUnlessEqual(self.S(), -42) self.assertEqual(self.S(), -42)
def test_double(self): def test_double(self):
self._dll.tf_d.restype = c_double self._dll.tf_d.restype = c_double
self._dll.tf_d.argtypes = (c_double,) self._dll.tf_d.argtypes = (c_double,)
self.failUnlessEqual(self._dll.tf_d(42.), 14.) self.assertEqual(self._dll.tf_d(42.), 14.)
self.failUnlessEqual(self.S(), 42) self.assertEqual(self.S(), 42)
def test_double_plus(self): def test_double_plus(self):
self._dll.tf_bd.restype = c_double self._dll.tf_bd.restype = c_double
self._dll.tf_bd.argtypes = (c_byte, c_double) self._dll.tf_bd.argtypes = (c_byte, c_double)
self.failUnlessEqual(self._dll.tf_bd(0, 42.), 14.) self.assertEqual(self._dll.tf_bd(0, 42.), 14.)
self.failUnlessEqual(self.S(), 42) self.assertEqual(self.S(), 42)
def test_longdouble(self): def test_longdouble(self):
self._dll.tf_D.restype = c_longdouble self._dll.tf_D.restype = c_longdouble
self._dll.tf_D.argtypes = (c_longdouble,) self._dll.tf_D.argtypes = (c_longdouble,)
self.failUnlessEqual(self._dll.tf_D(42.), 14.) self.assertEqual(self._dll.tf_D(42.), 14.)
self.failUnlessEqual(self.S(), 42) self.assertEqual(self.S(), 42)
def test_longdouble_plus(self): def test_longdouble_plus(self):
self._dll.tf_bD.restype = c_longdouble self._dll.tf_bD.restype = c_longdouble
self._dll.tf_bD.argtypes = (c_byte, c_longdouble) self._dll.tf_bD.argtypes = (c_byte, c_longdouble)
self.failUnlessEqual(self._dll.tf_bD(0, 42.), 14.) self.assertEqual(self._dll.tf_bD(0, 42.), 14.)
self.failUnlessEqual(self.S(), 42) self.assertEqual(self.S(), 42)
def test_callwithresult(self): def test_callwithresult(self):
def process_result(result): def process_result(result):
return result * 2 return result * 2
self._dll.tf_i.restype = process_result self._dll.tf_i.restype = process_result
self._dll.tf_i.argtypes = (c_int,) self._dll.tf_i.argtypes = (c_int,)
self.failUnlessEqual(self._dll.tf_i(42), 28) self.assertEqual(self._dll.tf_i(42), 28)
self.failUnlessEqual(self.S(), 42) self.assertEqual(self.S(), 42)
self.failUnlessEqual(self._dll.tf_i(-42), -28) self.assertEqual(self._dll.tf_i(-42), -28)
self.failUnlessEqual(self.S(), -42) self.assertEqual(self.S(), -42)
def test_void(self): def test_void(self):
self._dll.tv_i.restype = None self._dll.tv_i.restype = None
self._dll.tv_i.argtypes = (c_int,) self._dll.tv_i.argtypes = (c_int,)
self.failUnlessEqual(self._dll.tv_i(42), None) self.assertEqual(self._dll.tv_i(42), None)
self.failUnlessEqual(self.S(), 42) self.assertEqual(self.S(), 42)
self.failUnlessEqual(self._dll.tv_i(-42), None) self.assertEqual(self._dll.tv_i(-42), None)
self.failUnlessEqual(self.S(), -42) self.assertEqual(self.S(), -42)
# The following repeates the above tests with stdcall functions (where # The following repeates the above tests with stdcall functions (where
# they are available) # they are available)

10
Lib/ctypes/test/test_checkretval.py
View file

@ -14,16 +14,16 @@ def test_checkretval(self):
import _ctypes_test import _ctypes_test
dll = CDLL(_ctypes_test.__file__) dll = CDLL(_ctypes_test.__file__)
self.failUnlessEqual(42, dll._testfunc_p_p(42)) self.assertEqual(42, dll._testfunc_p_p(42))
dll._testfunc_p_p.restype = CHECKED dll._testfunc_p_p.restype = CHECKED
self.failUnlessEqual("42", dll._testfunc_p_p(42)) self.assertEqual("42", dll._testfunc_p_p(42))
dll._testfunc_p_p.restype = None dll._testfunc_p_p.restype = None
self.failUnlessEqual(None, dll._testfunc_p_p(42)) self.assertEqual(None, dll._testfunc_p_p(42))
del dll._testfunc_p_p.restype del dll._testfunc_p_p.restype
self.failUnlessEqual(42, dll._testfunc_p_p(42)) self.assertEqual(42, dll._testfunc_p_p(42))
try: try:
oledll oledll
@ -31,7 +31,7 @@ def test_checkretval(self):
pass pass
else: else:
def test_oledll(self): def test_oledll(self):
self.failUnlessRaises(WindowsError, self.assertRaises(WindowsError,
oledll.oleaut32.CreateTypeLib2, oledll.oleaut32.CreateTypeLib2,
0, None, None) 0, None, None)

26
Lib/ctypes/test/test_errno.py
View file

@ -15,11 +15,11 @@ def test_open(self):
libc_open.argtypes = c_char_p, c_int libc_open.argtypes = c_char_p, c_int
self.failUnlessEqual(libc_open("", 0), -1) self.assertEqual(libc_open("", 0), -1)
self.failUnlessEqual(get_errno(), errno.ENOENT) self.assertEqual(get_errno(), errno.ENOENT)
self.failUnlessEqual(set_errno(32), errno.ENOENT) self.assertEqual(set_errno(32), errno.ENOENT)
self.failUnlessEqual(get_errno(), 32) self.assertEqual(get_errno(), 32)
def _worker(): def _worker():
@ -31,14 +31,14 @@ def _worker():
else: else:
libc_open = libc.open libc_open = libc.open
libc_open.argtypes = c_char_p, c_int libc_open.argtypes = c_char_p, c_int
self.failUnlessEqual(libc_open("", 0), -1) self.assertEqual(libc_open("", 0), -1)
self.failUnlessEqual(get_errno(), 0) self.assertEqual(get_errno(), 0)
t = threading.Thread(target=_worker) t = threading.Thread(target=_worker)
t.start() t.start()
t.join() t.join()
self.failUnlessEqual(get_errno(), 32) self.assertEqual(get_errno(), 32)
set_errno(0) set_errno(0)
if os.name == "nt": if os.name == "nt":
@ -48,11 +48,11 @@ def test_GetLastError(self):
GetModuleHandle = dll.GetModuleHandleA GetModuleHandle = dll.GetModuleHandleA
GetModuleHandle.argtypes = [c_wchar_p] GetModuleHandle.argtypes = [c_wchar_p]
self.failUnlessEqual(0, GetModuleHandle("foo")) self.assertEqual(0, GetModuleHandle("foo"))
self.failUnlessEqual(get_last_error(), 126) self.assertEqual(get_last_error(), 126)
self.failUnlessEqual(set_last_error(32), 126) self.assertEqual(set_last_error(32), 126)
self.failUnlessEqual(get_last_error(), 32) self.assertEqual(get_last_error(), 32)
def _worker(): def _worker():
set_last_error(0) set_last_error(0)
@ -62,13 +62,13 @@ def _worker():
GetModuleHandle.argtypes = [c_wchar_p] GetModuleHandle.argtypes = [c_wchar_p]
GetModuleHandle("bar") GetModuleHandle("bar")
self.failUnlessEqual(get_last_error(), 0) self.assertEqual(get_last_error(), 0)
t = threading.Thread(target=_worker) t = threading.Thread(target=_worker)
t.start() t.start()
t.join() t.join()
self.failUnlessEqual(get_last_error(), 32) self.assertEqual(get_last_error(), 32)
set_last_error(0) set_last_error(0)

2
Lib/ctypes/test/test_find.py
View file

@ -76,7 +76,7 @@ def test_gle(self):
## sqrt = libm.sqrt ## sqrt = libm.sqrt
## sqrt.argtypes = (c_double,) ## sqrt.argtypes = (c_double,)
## sqrt.restype = c_double ## sqrt.restype = c_double
## self.failUnlessEqual(sqrt(2), math.sqrt(2)) ## self.assertEqual(sqrt(2), math.sqrt(2))
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

6
Lib/ctypes/test/test_frombuffer.py
View file

@ -16,14 +16,14 @@ def test_fom_buffer(self):
y = X.from_buffer(a) y = X.from_buffer(a)
self.assertEqual(y.c_int, a[0]) self.assertEqual(y.c_int, a[0])
self.failIf(y.init_called) self.assertFalse(y.init_called)
self.assertEqual(x[:], a.tolist()) self.assertEqual(x[:], a.tolist())
a[0], a[-1] = 200, -200 a[0], a[-1] = 200, -200
self.assertEqual(x[:], a.tolist()) self.assertEqual(x[:], a.tolist())
self.assert_(a in x._objects.values()) self.assertTrue(a in x._objects.values())
self.assertRaises(ValueError, self.assertRaises(ValueError,
c_int.from_buffer, a, -1) c_int.from_buffer, a, -1)
@ -49,7 +49,7 @@ def test_from_buffer_copy(self):
y = X.from_buffer_copy(a) y = X.from_buffer_copy(a)
self.assertEqual(y.c_int, a[0]) self.assertEqual(y.c_int, a[0])
self.failIf(y.init_called) self.assertFalse(y.init_called)
self.assertEqual(x[:], list(range(16))) self.assertEqual(x[:], list(range(16)))

32
Lib/ctypes/test/test_funcptr.py
View file

@ -18,10 +18,10 @@ def func(*args):
return len(args) return len(args)
x = X(func) x = X(func)
self.failUnlessEqual(x.restype, c_int) self.assertEqual(x.restype, c_int)
self.failUnlessEqual(x.argtypes, (c_int, c_int)) self.assertEqual(x.argtypes, (c_int, c_int))
self.failUnlessEqual(sizeof(x), sizeof(c_voidp)) self.assertEqual(sizeof(x), sizeof(c_voidp))
self.failUnlessEqual(sizeof(X), sizeof(c_voidp)) self.assertEqual(sizeof(X), sizeof(c_voidp))
def test_first(self): def test_first(self):
StdCallback = WINFUNCTYPE(c_int, c_int, c_int) StdCallback = WINFUNCTYPE(c_int, c_int, c_int)
@ -33,12 +33,12 @@ def func(a, b):
s = StdCallback(func) s = StdCallback(func)
c = CdeclCallback(func) c = CdeclCallback(func)
self.failUnlessEqual(s(1, 2), 3) self.assertEqual(s(1, 2), 3)
self.failUnlessEqual(c(1, 2), 3) self.assertEqual(c(1, 2), 3)
# The following no longer raises a TypeError - it is now # The following no longer raises a TypeError - it is now
# possible, as in C, to call cdecl functions with more parameters. # possible, as in C, to call cdecl functions with more parameters.
#self.assertRaises(TypeError, c, 1, 2, 3) #self.assertRaises(TypeError, c, 1, 2, 3)
self.failUnlessEqual(c(1, 2, 3, 4, 5, 6), 3) self.assertEqual(c(1, 2, 3, 4, 5, 6), 3)
if not WINFUNCTYPE is CFUNCTYPE and os.name != "ce": if not WINFUNCTYPE is CFUNCTYPE and os.name != "ce":
self.assertRaises(TypeError, s, 1, 2, 3) self.assertRaises(TypeError, s, 1, 2, 3)
@ -75,9 +75,9 @@ class WNDCLASS(Structure):
## "lpfnWndProc", WNDPROC_2(wndproc)) ## "lpfnWndProc", WNDPROC_2(wndproc))
# instead: # instead:
self.failUnless(WNDPROC is WNDPROC_2) self.assertTrue(WNDPROC is WNDPROC_2)
# 'wndclass.lpfnWndProc' leaks 94 references. Why? # 'wndclass.lpfnWndProc' leaks 94 references. Why?
self.failUnlessEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10) self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10)
f = wndclass.lpfnWndProc f = wndclass.lpfnWndProc
@ -85,7 +85,7 @@ class WNDCLASS(Structure):
del wndclass del wndclass
del wndproc del wndproc
self.failUnlessEqual(f(10, 11, 12, 13), 46) self.assertEqual(f(10, 11, 12, 13), 46)
def test_dllfunctions(self): def test_dllfunctions(self):
@ -97,8 +97,8 @@ def NoNullHandle(value):
strchr = lib.my_strchr strchr = lib.my_strchr
strchr.restype = c_char_p strchr.restype = c_char_p
strchr.argtypes = (c_char_p, c_char) strchr.argtypes = (c_char_p, c_char)
self.failUnlessEqual(strchr("abcdefghi", "b"), "bcdefghi") self.assertEqual(strchr("abcdefghi", "b"), "bcdefghi")
self.failUnlessEqual(strchr("abcdefghi", "x"), None) self.assertEqual(strchr("abcdefghi", "x"), None)
strtok = lib.my_strtok strtok = lib.my_strtok
@ -118,10 +118,10 @@ def c_string(init):
## b.value = s ## b.value = s
## b = c_string(s) ## b = c_string(s)
self.failUnlessEqual(strtok(b, b"\n"), "a") self.assertEqual(strtok(b, b"\n"), "a")
self.failUnlessEqual(strtok(None, b"\n"), "b") self.assertEqual(strtok(None, b"\n"), "b")
self.failUnlessEqual(strtok(None, b"\n"), "c") self.assertEqual(strtok(None, b"\n"), "c")
self.failUnlessEqual(strtok(None, b"\n"), None) self.assertEqual(strtok(None, b"\n"), None)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

100
Lib/ctypes/test/test_functions.py
View file

@ -71,8 +71,8 @@ def test_wchar_parm(self):
f = dll._testfunc_i_bhilfd f = dll._testfunc_i_bhilfd
f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double] f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
result = f(1, "x", 3, 4, 5.0, 6.0) result = f(1, "x", 3, 4, 5.0, 6.0)
self.failUnlessEqual(result, 139) self.assertEqual(result, 139)
self.failUnlessEqual(type(result), int) self.assertEqual(type(result), int)
def test_wchar_result(self): def test_wchar_result(self):
try: try:
@ -83,38 +83,38 @@ def test_wchar_result(self):
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
f.restype = c_wchar f.restype = c_wchar
result = f(0, 0, 0, 0, 0, 0) result = f(0, 0, 0, 0, 0, 0)
self.failUnlessEqual(result, '\x00') self.assertEqual(result, '\x00')
def test_voidresult(self): def test_voidresult(self):
f = dll._testfunc_v f = dll._testfunc_v
f.restype = None f.restype = None
f.argtypes = [c_int, c_int, POINTER(c_int)] f.argtypes = [c_int, c_int, POINTER(c_int)]
result = c_int() result = c_int()
self.failUnlessEqual(None, f(1, 2, byref(result))) self.assertEqual(None, f(1, 2, byref(result)))
self.failUnlessEqual(result.value, 3) self.assertEqual(result.value, 3)
def test_intresult(self): def test_intresult(self):
f = dll._testfunc_i_bhilfd f = dll._testfunc_i_bhilfd
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
f.restype = c_int f.restype = c_int
result = f(1, 2, 3, 4, 5.0, 6.0) result = f(1, 2, 3, 4, 5.0, 6.0)
self.failUnlessEqual(result, 21) self.assertEqual(result, 21)
self.failUnlessEqual(type(result), int) self.assertEqual(type(result), int)
result = f(-1, -2, -3, -4, -5.0, -6.0) result = f(-1, -2, -3, -4, -5.0, -6.0)
self.failUnlessEqual(result, -21) self.assertEqual(result, -21)
self.failUnlessEqual(type(result), int) self.assertEqual(type(result), int)
# If we declare the function to return a short, # If we declare the function to return a short,
# is the high part split off? # is the high part split off?
f.restype = c_short f.restype = c_short
result = f(1, 2, 3, 4, 5.0, 6.0) result = f(1, 2, 3, 4, 5.0, 6.0)
self.failUnlessEqual(result, 21) self.assertEqual(result, 21)
self.failUnlessEqual(type(result), int) self.assertEqual(type(result), int)
result = f(1, 2, 3, 0x10004, 5.0, 6.0) result = f(1, 2, 3, 0x10004, 5.0, 6.0)
self.failUnlessEqual(result, 21) self.assertEqual(result, 21)
self.failUnlessEqual(type(result), int) self.assertEqual(type(result), int)
# You cannot assing character format codes as restype any longer # You cannot assing character format codes as restype any longer
self.assertRaises(TypeError, setattr, f, "restype", "i") self.assertRaises(TypeError, setattr, f, "restype", "i")
@ -124,36 +124,36 @@ def test_floatresult(self):
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
f.restype = c_float f.restype = c_float
result = f(1, 2, 3, 4, 5.0, 6.0) result = f(1, 2, 3, 4, 5.0, 6.0)
self.failUnlessEqual(result, 21) self.assertEqual(result, 21)
self.failUnlessEqual(type(result), float) self.assertEqual(type(result), float)
result = f(-1, -2, -3, -4, -5.0, -6.0) result = f(-1, -2, -3, -4, -5.0, -6.0)
self.failUnlessEqual(result, -21) self.assertEqual(result, -21)
self.failUnlessEqual(type(result), float) self.assertEqual(type(result), float)
def test_doubleresult(self): def test_doubleresult(self):
f = dll._testfunc_d_bhilfd f = dll._testfunc_d_bhilfd
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
f.restype = c_double f.restype = c_double
result = f(1, 2, 3, 4, 5.0, 6.0) result = f(1, 2, 3, 4, 5.0, 6.0)
self.failUnlessEqual(result, 21) self.assertEqual(result, 21)
self.failUnlessEqual(type(result), float) self.assertEqual(type(result), float)
result = f(-1, -2, -3, -4, -5.0, -6.0) result = f(-1, -2, -3, -4, -5.0, -6.0)
self.failUnlessEqual(result, -21) self.assertEqual(result, -21)
self.failUnlessEqual(type(result), float) self.assertEqual(type(result), float)
def test_longdoubleresult(self): def test_longdoubleresult(self):
f = dll._testfunc_D_bhilfD f = dll._testfunc_D_bhilfD
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble] f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble]
f.restype = c_longdouble f.restype = c_longdouble
result = f(1, 2, 3, 4, 5.0, 6.0) result = f(1, 2, 3, 4, 5.0, 6.0)
self.failUnlessEqual(result, 21) self.assertEqual(result, 21)
self.failUnlessEqual(type(result), float) self.assertEqual(type(result), float)
result = f(-1, -2, -3, -4, -5.0, -6.0) result = f(-1, -2, -3, -4, -5.0, -6.0)
self.failUnlessEqual(result, -21) self.assertEqual(result, -21)
self.failUnlessEqual(type(result), float) self.assertEqual(type(result), float)
def test_longlongresult(self): def test_longlongresult(self):
try: try:
@ -164,23 +164,23 @@ def test_longlongresult(self):
f.restype = c_longlong f.restype = c_longlong
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
result = f(1, 2, 3, 4, 5.0, 6.0) result = f(1, 2, 3, 4, 5.0, 6.0)
self.failUnlessEqual(result, 21) self.assertEqual(result, 21)
f = dll._testfunc_q_bhilfdq f = dll._testfunc_q_bhilfdq
f.restype = c_longlong f.restype = c_longlong
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double, c_longlong] f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double, c_longlong]
result = f(1, 2, 3, 4, 5.0, 6.0, 21) result = f(1, 2, 3, 4, 5.0, 6.0, 21)
self.failUnlessEqual(result, 42) self.assertEqual(result, 42)
def test_stringresult(self): def test_stringresult(self):
f = dll._testfunc_p_p f = dll._testfunc_p_p
f.argtypes = None f.argtypes = None
f.restype = c_char_p f.restype = c_char_p
result = f(b"123") result = f(b"123")
self.failUnlessEqual(result, "123") self.assertEqual(result, "123")
result = f(None) result = f(None)
self.failUnlessEqual(result, None) self.assertEqual(result, None)
def test_pointers(self): def test_pointers(self):
f = dll._testfunc_p_p f = dll._testfunc_p_p
@ -193,29 +193,29 @@ def test_pointers(self):
v = c_int(42) v = c_int(42)
self.failUnlessEqual(pointer(v).contents.value, 42) self.assertEqual(pointer(v).contents.value, 42)
result = f(pointer(v)) result = f(pointer(v))
self.failUnlessEqual(type(result), POINTER(c_int)) self.assertEqual(type(result), POINTER(c_int))
self.failUnlessEqual(result.contents.value, 42) self.assertEqual(result.contents.value, 42)
# This on works... # This on works...
result = f(pointer(v)) result = f(pointer(v))
self.failUnlessEqual(result.contents.value, v.value) self.assertEqual(result.contents.value, v.value)
p = pointer(c_int(99)) p = pointer(c_int(99))
result = f(p) result = f(p)
self.failUnlessEqual(result.contents.value, 99) self.assertEqual(result.contents.value, 99)
arg = byref(v) arg = byref(v)
result = f(arg) result = f(arg)
self.failIfEqual(result.contents, v.value) self.assertNotEqual(result.contents, v.value)
self.assertRaises(ArgumentError, f, byref(c_short(22))) self.assertRaises(ArgumentError, f, byref(c_short(22)))
# It is dangerous, however, because you don't control the lifetime # It is dangerous, however, because you don't control the lifetime
# of the pointer: # of the pointer:
result = f(byref(c_int(99))) result = f(byref(c_int(99)))
self.failIfEqual(result.contents, 99) self.assertNotEqual(result.contents, 99)
def test_errors(self): def test_errors(self):
f = dll._testfunc_p_p f = dll._testfunc_p_p
@ -242,7 +242,7 @@ def callback(v):
cb = CallBack(callback) cb = CallBack(callback)
f(2**18, cb) f(2**18, cb)
self.failUnlessEqual(args, expected) self.assertEqual(args, expected)
################################################################ ################################################################
@ -259,13 +259,13 @@ def callback(value):
cb = MyCallback(callback) cb = MyCallback(callback)
result = f(-10, cb) result = f(-10, cb)
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
# test with prototype # test with prototype
f.argtypes = [c_int, MyCallback] f.argtypes = [c_int, MyCallback]
cb = MyCallback(callback) cb = MyCallback(callback)
result = f(-10, cb) result = f(-10, cb)
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
AnotherCallback = WINFUNCTYPE(c_int, c_int, c_int, c_int, c_int) AnotherCallback = WINFUNCTYPE(c_int, c_int, c_int, c_int, c_int)
@ -288,12 +288,12 @@ def test_callbacks_2(self):
def callback(value): def callback(value):
#print "called back with", value #print "called back with", value
self.failUnlessEqual(type(value), int) self.assertEqual(type(value), int)
return value return value
cb = MyCallback(callback) cb = MyCallback(callback)
result = f(-10, cb) result = f(-10, cb)
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
def test_longlong_callbacks(self): def test_longlong_callbacks(self):
@ -305,12 +305,12 @@ def test_longlong_callbacks(self):
f.argtypes = [c_longlong, MyCallback] f.argtypes = [c_longlong, MyCallback]
def callback(value): def callback(value):
self.failUnless(isinstance(value, int)) self.assertTrue(isinstance(value, int))
return value & 0x7FFFFFFF return value & 0x7FFFFFFF
cb = MyCallback(callback) cb = MyCallback(callback)
self.failUnlessEqual(13577625587, f(1000000000000, cb)) self.assertEqual(13577625587, f(1000000000000, cb))
def test_errors(self): def test_errors(self):
self.assertRaises(AttributeError, getattr, dll, "_xxx_yyy") self.assertRaises(AttributeError, getattr, dll, "_xxx_yyy")
@ -325,7 +325,7 @@ def test_byval(self):
result = dll._testfunc_byval(ptin, byref(ptout)) result = dll._testfunc_byval(ptin, byref(ptout))
got = result, ptout.x, ptout.y got = result, ptout.x, ptout.y
expected = 3, 1, 2 expected = 3, 1, 2
self.failUnlessEqual(got, expected) self.assertEqual(got, expected)
# with prototype # with prototype
ptin = POINT(101, 102) ptin = POINT(101, 102)
@ -335,7 +335,7 @@ def test_byval(self):
result = dll._testfunc_byval(ptin, byref(ptout)) result = dll._testfunc_byval(ptin, byref(ptout))
got = result, ptout.x, ptout.y got = result, ptout.x, ptout.y
expected = 203, 101, 102 expected = 203, 101, 102
self.failUnlessEqual(got, expected) self.assertEqual(got, expected)
def test_struct_return_2H(self): def test_struct_return_2H(self):
class S2H(Structure): class S2H(Structure):
@ -345,7 +345,7 @@ class S2H(Structure):
dll.ret_2h_func.argtypes = [S2H] dll.ret_2h_func.argtypes = [S2H]
inp = S2H(99, 88) inp = S2H(99, 88)
s2h = dll.ret_2h_func(inp) s2h = dll.ret_2h_func(inp)
self.failUnlessEqual((s2h.x, s2h.y), (99*2, 88*3)) self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
if sys.platform == "win32": if sys.platform == "win32":
def test_struct_return_2H_stdcall(self): def test_struct_return_2H_stdcall(self):
@ -356,7 +356,7 @@ class S2H(Structure):
windll.s_ret_2h_func.restype = S2H windll.s_ret_2h_func.restype = S2H
windll.s_ret_2h_func.argtypes = [S2H] windll.s_ret_2h_func.argtypes = [S2H]
s2h = windll.s_ret_2h_func(S2H(99, 88)) s2h = windll.s_ret_2h_func(S2H(99, 88))
self.failUnlessEqual((s2h.x, s2h.y), (99*2, 88*3)) self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
def test_struct_return_8H(self): def test_struct_return_8H(self):
class S8I(Structure): class S8I(Structure):
@ -372,7 +372,7 @@ class S8I(Structure):
dll.ret_8i_func.argtypes = [S8I] dll.ret_8i_func.argtypes = [S8I]
inp = S8I(9, 8, 7, 6, 5, 4, 3, 2) inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
s8i = dll.ret_8i_func(inp) s8i = dll.ret_8i_func(inp)
self.failUnlessEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
(9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9)) (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
if sys.platform == "win32": if sys.platform == "win32":
@ -390,7 +390,7 @@ class S8I(Structure):
windll.s_ret_8i_func.argtypes = [S8I] windll.s_ret_8i_func.argtypes = [S8I]
inp = S8I(9, 8, 7, 6, 5, 4, 3, 2) inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
s8i = windll.s_ret_8i_func(inp) s8i = windll.s_ret_8i_func(inp)
self.failUnlessEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
(9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9)) (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
def test_sf1651235(self): def test_sf1651235(self):
@ -401,7 +401,7 @@ def callback(*args):
return 0 return 0
callback = proto(callback) callback = proto(callback)
self.failUnlessRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT())) self.assertRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT()))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

2
Lib/ctypes/test/test_incomplete.py
View file

@ -30,7 +30,7 @@ class cell(Structure):
for i in range(8): for i in range(8):
result.append(p.name) result.append(p.name)
p = p.next[0] p = p.next[0]
self.failUnlessEqual(result, ["foo", "bar"] * 4) self.assertEqual(result, ["foo", "bar"] * 4)
# to not leak references, we must clean _pointer_type_cache # to not leak references, we must clean _pointer_type_cache
from ctypes import _pointer_type_cache from ctypes import _pointer_type_cache

12
Lib/ctypes/test/test_init.py
View file

@ -24,17 +24,17 @@ def test_get(self):
# make sure the only accessing a nested structure # make sure the only accessing a nested structure
# doesn't call the structure's __new__ and __init__ # doesn't call the structure's __new__ and __init__
y = Y() y = Y()
self.failUnlessEqual((y.x.a, y.x.b), (0, 0)) self.assertEqual((y.x.a, y.x.b), (0, 0))
self.failUnlessEqual(y.x.new_was_called, False) self.assertEqual(y.x.new_was_called, False)
# But explicitely creating an X structure calls __new__ and __init__, of course. # But explicitely creating an X structure calls __new__ and __init__, of course.
x = X() x = X()
self.failUnlessEqual((x.a, x.b), (9, 12)) self.assertEqual((x.a, x.b), (9, 12))
self.failUnlessEqual(x.new_was_called, True) self.assertEqual(x.new_was_called, True)
y.x = x y.x = x
self.failUnlessEqual((y.x.a, y.x.b), (9, 12)) self.assertEqual((y.x.a, y.x.b), (9, 12))
self.failUnlessEqual(y.x.new_was_called, False) self.assertEqual(y.x.new_was_called, False)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

28
Lib/ctypes/test/test_internals.py
View file

@ -18,22 +18,22 @@
""" """
class ObjectsTestCase(unittest.TestCase): class ObjectsTestCase(unittest.TestCase):
def failUnlessSame(self, a, b): def assertTrueSame(self, a, b):
self.failUnlessEqual(id(a), id(b)) self.assertEqual(id(a), id(b))
def test_ints(self): def test_ints(self):
i = 42000123 i = 42000123
rc = grc(i) rc = grc(i)
ci = c_int(i) ci = c_int(i)
self.failUnlessEqual(rc, grc(i)) self.assertEqual(rc, grc(i))
self.failUnlessEqual(ci._objects, None) self.assertEqual(ci._objects, None)
def test_c_char_p(self): def test_c_char_p(self):
s = b"Hello, World" s = b"Hello, World"
rc = grc(s) rc = grc(s)
cs = c_char_p(s) cs = c_char_p(s)
self.failUnlessEqual(rc + 1, grc(s)) self.assertEqual(rc + 1, grc(s))
self.failUnlessSame(cs._objects, s) self.assertTrueSame(cs._objects, s)
def test_simple_struct(self): def test_simple_struct(self):
class X(Structure): class X(Structure):
@ -42,10 +42,10 @@ class X(Structure):
a = 421234 a = 421234
b = 421235 b = 421235
x = X() x = X()
self.failUnlessEqual(x._objects, None) self.assertEqual(x._objects, None)
x.a = a x.a = a
x.b = b x.b = b
self.failUnlessEqual(x._objects, None) self.assertEqual(x._objects, None)
def test_embedded_structs(self): def test_embedded_structs(self):
class X(Structure): class X(Structure):
@ -55,13 +55,13 @@ class Y(Structure):
_fields_ = [("x", X), ("y", X)] _fields_ = [("x", X), ("y", X)]
y = Y() y = Y()
self.failUnlessEqual(y._objects, None) self.assertEqual(y._objects, None)
x1, x2 = X(), X() x1, x2 = X(), X()
y.x, y.y = x1, x2 y.x, y.y = x1, x2
self.failUnlessEqual(y._objects, {"0": {}, "1": {}}) self.assertEqual(y._objects, {"0": {}, "1": {}})
x1.a, x2.b = 42, 93 x1.a, x2.b = 42, 93
self.failUnlessEqual(y._objects, {"0": {}, "1": {}}) self.assertEqual(y._objects, {"0": {}, "1": {}})
def test_xxx(self): def test_xxx(self):
class X(Structure): class X(Structure):
@ -76,12 +76,12 @@ class Y(Structure):
x = X() x = X()
x.a = s1 x.a = s1
x.b = s2 x.b = s2
self.failUnlessEqual(x._objects, {"0": bytes(s1, "ascii"), self.assertEqual(x._objects, {"0": bytes(s1, "ascii"),
"1": bytes(s2, "ascii")}) "1": bytes(s2, "ascii")})
y = Y() y = Y()
y.x = x y.x = x
self.failUnlessEqual(y._objects, {"0": {"0": bytes(s1, "ascii"), self.assertEqual(y._objects, {"0": {"0": bytes(s1, "ascii"),
"1": bytes(s2, "ascii")}}) "1": bytes(s2, "ascii")}})
## x = y.x ## x = y.x
## del y ## del y
@ -93,7 +93,7 @@ class X(Structure):
A = c_int*4 A = c_int*4
a = A(11, 22, 33, 44) a = A(11, 22, 33, 44)
self.failUnlessEqual(a._objects, None) self.assertEqual(a._objects, None)
x = X() x = X()
x.data = a x.data = a

2
Lib/ctypes/test/test_keeprefs.py
View file

@ -91,7 +91,7 @@ class PointerTestCase(unittest.TestCase):
def test_p_cint(self): def test_p_cint(self):
i = c_int(42) i = c_int(42)
x = pointer(i) x = pointer(i)
self.failUnlessEqual(x._objects, {'1': i}) self.assertEqual(x._objects, {'1': i})
class DeletePointerTestCase(unittest.TestCase): class DeletePointerTestCase(unittest.TestCase):
def X_test(self): def X_test(self):

6
Lib/ctypes/test/test_libc.py
View file

@ -13,9 +13,9 @@ class LibTest(unittest.TestCase):
def test_sqrt(self): def test_sqrt(self):
lib.my_sqrt.argtypes = c_double, lib.my_sqrt.argtypes = c_double,
lib.my_sqrt.restype = c_double lib.my_sqrt.restype = c_double
self.failUnlessEqual(lib.my_sqrt(4.0), 2.0) self.assertEqual(lib.my_sqrt(4.0), 2.0)
import math import math
self.failUnlessEqual(lib.my_sqrt(2.0), math.sqrt(2.0)) self.assertEqual(lib.my_sqrt(2.0), math.sqrt(2.0))
def test_qsort(self): def test_qsort(self):
comparefunc = CFUNCTYPE(c_int, POINTER(c_char), POINTER(c_char)) comparefunc = CFUNCTYPE(c_int, POINTER(c_char), POINTER(c_char))
@ -27,7 +27,7 @@ def sort(a, b):
chars = create_string_buffer("spam, spam, and spam") chars = create_string_buffer("spam, spam, and spam")
lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort)) lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort))
self.failUnlessEqual(chars.raw, b" ,,aaaadmmmnpppsss\x00") self.assertEqual(chars.raw, b" ,,aaaadmmmnpppsss\x00")
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

12
Lib/ctypes/test/test_loading.py
View file

@ -43,7 +43,7 @@ def test_find(self):
if os.name in ("nt", "ce"): if os.name in ("nt", "ce"):
def test_load_library(self): def test_load_library(self):
self.failIf(libc_name is None) self.assertFalse(libc_name is None)
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"))
@ -70,9 +70,9 @@ def test_load_ordinal_functions(self):
a_name = addressof(func_name) a_name = addressof(func_name)
f_ord_addr = c_void_p.from_address(a_ord).value f_ord_addr = c_void_p.from_address(a_ord).value
f_name_addr = c_void_p.from_address(a_name).value f_name_addr = c_void_p.from_address(a_name).value
self.failUnlessEqual(hex(f_ord_addr), hex(f_name_addr)) self.assertEqual(hex(f_ord_addr), hex(f_name_addr))
self.failUnlessRaises(AttributeError, dll.__getitem__, 1234) self.assertRaises(AttributeError, dll.__getitem__, 1234)
if os.name == "nt": if os.name == "nt":
def test_1703286_A(self): def test_1703286_A(self):
@ -94,13 +94,13 @@ def test_1703286_B(self):
advapi32 = windll.advapi32 advapi32 = windll.advapi32
# Calling CloseEventLog with a NULL argument should fail, # Calling CloseEventLog with a NULL argument should fail,
# but the call should not segfault or so. # but the call should not segfault or so.
self.failUnlessEqual(0, advapi32.CloseEventLog(None)) self.assertEqual(0, advapi32.CloseEventLog(None))
windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
windll.kernel32.GetProcAddress.restype = c_void_p windll.kernel32.GetProcAddress.restype = c_void_p
proc = windll.kernel32.GetProcAddress(advapi32._handle, "CloseEventLog") proc = windll.kernel32.GetProcAddress(advapi32._handle, "CloseEventLog")
self.failUnless(proc) self.assertTrue(proc)
# This is the real test: call the function via 'call_function' # This is the real test: call the function via 'call_function'
self.failUnlessEqual(0, call_function(proc, (None,))) self.assertEqual(0, call_function(proc, (None,)))
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

8
Lib/ctypes/test/test_macholib.py
View file

@ -48,14 +48,14 @@ class MachOTest(unittest.TestCase):
if sys.platform == "darwin": if sys.platform == "darwin":
def test_find(self): def test_find(self):
self.failUnlessEqual(find_lib('pthread'), self.assertEqual(find_lib('pthread'),
'/usr/lib/libSystem.B.dylib') '/usr/lib/libSystem.B.dylib')
result = find_lib('z') result = find_lib('z')
self.failUnless(result.startswith('/usr/lib/libz.1')) self.assertTrue(result.startswith('/usr/lib/libz.1'))
self.failUnless(result.endswith('.dylib')) self.assertTrue(result.endswith('.dylib'))
self.failUnlessEqual(find_lib('IOKit'), self.assertEqual(find_lib('IOKit'),
'/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit') '/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit')
if __name__ == "__main__": if __name__ == "__main__":

48
Lib/ctypes/test/test_memfunctions.py
View file

@ -19,45 +19,45 @@ def test_memmove(self):
a = create_string_buffer(1000000) a = create_string_buffer(1000000)
p = b"Hello, World" p = b"Hello, World"
result = memmove(a, p, len(p)) result = memmove(a, p, len(p))
self.failUnlessEqual(a.value, b"Hello, World") self.assertEqual(a.value, b"Hello, World")
self.failUnlessEqual(string_at(result), b"Hello, World") self.assertEqual(string_at(result), b"Hello, World")
self.failUnlessEqual(string_at(result, 5), b"Hello") self.assertEqual(string_at(result, 5), b"Hello")
self.failUnlessEqual(string_at(result, 16), b"Hello, World\0\0\0\0") self.assertEqual(string_at(result, 16), b"Hello, World\0\0\0\0")
self.failUnlessEqual(string_at(result, 0), b"") self.assertEqual(string_at(result, 0), b"")
def test_memset(self): def test_memset(self):
a = create_string_buffer(1000000) a = create_string_buffer(1000000)
result = memset(a, ord('x'), 16) result = memset(a, ord('x'), 16)
self.failUnlessEqual(a.value, b"xxxxxxxxxxxxxxxx") self.assertEqual(a.value, b"xxxxxxxxxxxxxxxx")
self.failUnlessEqual(string_at(result), b"xxxxxxxxxxxxxxxx") self.assertEqual(string_at(result), b"xxxxxxxxxxxxxxxx")
self.failUnlessEqual(string_at(a), b"xxxxxxxxxxxxxxxx") self.assertEqual(string_at(a), b"xxxxxxxxxxxxxxxx")
self.failUnlessEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0") self.assertEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0")
def test_cast(self): def test_cast(self):
a = (c_ubyte * 32)(*map(ord, "abcdef")) a = (c_ubyte * 32)(*map(ord, "abcdef"))
self.failUnlessEqual(cast(a, c_char_p).value, "abcdef") self.assertEqual(cast(a, c_char_p).value, "abcdef")
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7], self.assertEqual(cast(a, POINTER(c_byte))[:7],
[97, 98, 99, 100, 101, 102, 0]) [97, 98, 99, 100, 101, 102, 0])
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:], self.assertEqual(cast(a, POINTER(c_byte))[:7:],
[97, 98, 99, 100, 101, 102, 0]) [97, 98, 99, 100, 101, 102, 0])
self.failUnlessEqual(cast(a, POINTER(c_byte))[6:-1:-1], self.assertEqual(cast(a, POINTER(c_byte))[6:-1:-1],
[0, 102, 101, 100, 99, 98, 97]) [0, 102, 101, 100, 99, 98, 97])
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:2], self.assertEqual(cast(a, POINTER(c_byte))[:7:2],
[97, 99, 101, 0]) [97, 99, 101, 0])
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:7], self.assertEqual(cast(a, POINTER(c_byte))[:7:7],
[97]) [97])
def test_string_at(self): def test_string_at(self):
s = string_at(b"foo bar") s = string_at(b"foo bar")
# XXX The following may be wrong, depending on how Python # XXX The following may be wrong, depending on how Python
# manages string instances # manages string instances
self.failUnlessEqual(2, sys.getrefcount(s)) self.assertEqual(2, sys.getrefcount(s))
self.failUnless(s, "foo bar") self.assertTrue(s, "foo bar")
self.failUnlessEqual(string_at(b"foo bar", 7), b"foo bar") self.assertEqual(string_at(b"foo bar", 7), b"foo bar")
self.failUnlessEqual(string_at(b"foo bar", 3), b"foo") self.assertEqual(string_at(b"foo bar", 3), b"foo")
try: try:
create_unicode_buffer create_unicode_buffer
@ -68,12 +68,12 @@ def test_wstring_at(self):
p = create_unicode_buffer("Hello, World") p = create_unicode_buffer("Hello, World")
a = create_unicode_buffer(1000000) a = create_unicode_buffer(1000000)
result = memmove(a, p, len(p) * sizeof(c_wchar)) result = memmove(a, p, len(p) * sizeof(c_wchar))
self.failUnlessEqual(a.value, "Hello, World") self.assertEqual(a.value, "Hello, World")
self.failUnlessEqual(wstring_at(a), "Hello, World") self.assertEqual(wstring_at(a), "Hello, World")
self.failUnlessEqual(wstring_at(a, 5), "Hello") self.assertEqual(wstring_at(a, 5), "Hello")
self.failUnlessEqual(wstring_at(a, 16), "Hello, World\0\0\0\0") self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
self.failUnlessEqual(wstring_at(a, 0), "") self.assertEqual(wstring_at(a, 0), "")
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

62
Lib/ctypes/test/test_numbers.py
View file

@ -55,25 +55,25 @@ class NumberTestCase(unittest.TestCase):
def test_default_init(self): def test_default_init(self):
# default values are set to zero # default values are set to zero
for t in signed_types + unsigned_types + float_types: for t in signed_types + unsigned_types + float_types:
self.failUnlessEqual(t().value, 0) self.assertEqual(t().value, 0)
def test_unsigned_values(self): def test_unsigned_values(self):
# the value given to the constructor is available # the value given to the constructor is available
# as the 'value' attribute # as the 'value' attribute
for t, (l, h) in zip(unsigned_types, unsigned_ranges): for t, (l, h) in zip(unsigned_types, unsigned_ranges):
self.failUnlessEqual(t(l).value, l) self.assertEqual(t(l).value, l)
self.failUnlessEqual(t(h).value, h) self.assertEqual(t(h).value, h)
def test_signed_values(self): def test_signed_values(self):
# see above # see above
for t, (l, h) in zip(signed_types, signed_ranges): for t, (l, h) in zip(signed_types, signed_ranges):
self.failUnlessEqual(t(l).value, l) self.assertEqual(t(l).value, l)
self.failUnlessEqual(t(h).value, h) self.assertEqual(t(h).value, h)
def test_bool_values(self): def test_bool_values(self):
from operator import truth from operator import truth
for t, v in zip(bool_types, bool_values): for t, v in zip(bool_types, bool_values):
self.failUnlessEqual(t(v).value, truth(v)) self.assertEqual(t(v).value, truth(v))
def test_typeerror(self): def test_typeerror(self):
# Only numbers are allowed in the contructor, # Only numbers are allowed in the contructor,
@ -93,13 +93,13 @@ def test_from_param(self):
# the from_param class method attribute always # the from_param class method attribute always
# returns PyCArgObject instances # returns PyCArgObject instances
for t in signed_types + unsigned_types + float_types: for t in signed_types + unsigned_types + float_types:
self.failUnlessEqual(ArgType, type(t.from_param(0))) self.assertEqual(ArgType, type(t.from_param(0)))
def test_byref(self): def test_byref(self):
# calling byref returns also a PyCArgObject instance # calling byref returns also a PyCArgObject instance
for t in signed_types + unsigned_types + float_types + bool_types: for t in signed_types + unsigned_types + float_types + bool_types:
parm = byref(t()) parm = byref(t())
self.failUnlessEqual(ArgType, type(parm)) self.assertEqual(ArgType, type(parm))
def test_floats(self): def test_floats(self):
@ -110,10 +110,10 @@ def __float__(self):
return 2.0 return 2.0
f = FloatLike() f = FloatLike()
for t in float_types: for t in float_types:
self.failUnlessEqual(t(2.0).value, 2.0) self.assertEqual(t(2.0).value, 2.0)
self.failUnlessEqual(t(2).value, 2.0) self.assertEqual(t(2).value, 2.0)
self.failUnlessEqual(t(2).value, 2.0) self.assertEqual(t(2).value, 2.0)
self.failUnlessEqual(t(f).value, 2.0) self.assertEqual(t(f).value, 2.0)
def test_integers(self): def test_integers(self):
class FloatLike(object): class FloatLike(object):
@ -129,7 +129,7 @@ def __int__(self):
for t in signed_types + unsigned_types: for t in signed_types + unsigned_types:
self.assertRaises(TypeError, t, 3.14) self.assertRaises(TypeError, t, 3.14)
self.assertRaises(TypeError, t, f) self.assertRaises(TypeError, t, f)
self.failUnlessEqual(t(i).value, 2) self.assertEqual(t(i).value, 2)
def test_sizes(self): def test_sizes(self):
for t in signed_types + unsigned_types + float_types + bool_types: for t in signed_types + unsigned_types + float_types + bool_types:
@ -138,9 +138,9 @@ def test_sizes(self):
except struct.error: except struct.error:
continue continue
# sizeof of the type... # sizeof of the type...
self.failUnlessEqual(sizeof(t), size) self.assertEqual(sizeof(t), size)
# and sizeof of an instance # and sizeof of an instance
self.failUnlessEqual(sizeof(t()), size) self.assertEqual(sizeof(t()), size)
def test_alignments(self): def test_alignments(self):
for t in signed_types + unsigned_types + float_types: for t in signed_types + unsigned_types + float_types:
@ -148,10 +148,10 @@ def test_alignments(self):
align = struct.calcsize("c%c" % code) - struct.calcsize(code) align = struct.calcsize("c%c" % code) - struct.calcsize(code)
# alignment of the type... # alignment of the type...
self.failUnlessEqual((code, alignment(t)), self.assertEqual((code, alignment(t)),
(code, align)) (code, align))
# and alignment of an instance # and alignment of an instance
self.failUnlessEqual((code, alignment(t())), self.assertEqual((code, alignment(t())),
(code, align)) (code, align))
def test_int_from_address(self): def test_int_from_address(self):
@ -167,12 +167,12 @@ def test_int_from_address(self):
# v now is an integer at an 'external' memory location # v now is an integer at an 'external' memory location
v = t.from_address(a.buffer_info()[0]) v = t.from_address(a.buffer_info()[0])
self.failUnlessEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
self.failUnlessEqual(type(v), t) self.assertEqual(type(v), t)
# changing the value at the memory location changes v's value also # changing the value at the memory location changes v's value also
a[0] = 42 a[0] = 42
self.failUnlessEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
def test_float_from_address(self): def test_float_from_address(self):
@ -180,11 +180,11 @@ def test_float_from_address(self):
for t in float_types: for t in float_types:
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.failUnlessEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
self.failUnless(type(v) is t) self.assertTrue(type(v) is t)
a[0] = 2.3456e17 a[0] = 2.3456e17
self.failUnlessEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
self.failUnless(type(v) is t) self.assertTrue(type(v) is t)
def test_char_from_address(self): def test_char_from_address(self):
from ctypes import c_char from ctypes import c_char
@ -193,11 +193,11 @@ def test_char_from_address(self):
a = array('b', [0]) a = array('b', [0])
a[0] = ord('x') a[0] = ord('x')
v = c_char.from_address(a.buffer_info()[0]) v = c_char.from_address(a.buffer_info()[0])
self.failUnlessEqual(v.value, b'x') self.assertEqual(v.value, b'x')
self.failUnless(type(v) is c_char) self.assertTrue(type(v) is c_char)
a[0] = ord('?') a[0] = ord('?')
self.failUnlessEqual(v.value, b'?') self.assertEqual(v.value, b'?')
# array does not support c_bool / 't' # array does not support c_bool / 't'
# def test_bool_from_address(self): # def test_bool_from_address(self):
@ -205,11 +205,11 @@ def test_char_from_address(self):
# from array import array # from array import array
# a = array(c_bool._type_, [True]) # a = array(c_bool._type_, [True])
# v = t.from_address(a.buffer_info()[0]) # v = t.from_address(a.buffer_info()[0])
# self.failUnlessEqual(v.value, a[0]) # self.assertEqual(v.value, a[0])
# self.failUnlessEqual(type(v) is t) # self.assertEqual(type(v) is t)
# a[0] = False # a[0] = False
# self.failUnlessEqual(v.value, a[0]) # self.assertEqual(v.value, a[0])
# self.failUnlessEqual(type(v) is t) # self.assertEqual(type(v) is t)
def test_init(self): def test_init(self):
# c_int() can be initialized from Python's int, and c_int. # c_int() can be initialized from Python's int, and c_int.

34
Lib/ctypes/test/test_parameters.py
View file

@ -33,8 +33,8 @@ def from_param(cls, value):
return value * 4 return value * 4
from_param = classmethod(from_param) from_param = classmethod(from_param)
self.failUnlessEqual(CVOIDP.from_param("abc"), "abcabc") self.assertEqual(CVOIDP.from_param("abc"), "abcabc")
self.failUnlessEqual(CCHARP.from_param("abc"), "abcabcabcabc") self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc")
try: try:
from ctypes import c_wchar_p from ctypes import c_wchar_p
@ -46,7 +46,7 @@ def from_param(cls, value):
return value * 3 return value * 3
from_param = classmethod(from_param) from_param = classmethod(from_param)
self.failUnlessEqual(CWCHARP.from_param("abc"), "abcabcabc") self.assertEqual(CWCHARP.from_param("abc"), "abcabcabc")
# XXX Replace by c_char_p tests # XXX Replace by c_char_p tests
def test_cstrings(self): def test_cstrings(self):
@ -55,10 +55,10 @@ def test_cstrings(self):
# 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 = b"123" s = b"123"
self.failUnless(c_char_p.from_param(s)._obj is s) self.assertTrue(c_char_p.from_param(s)._obj is s)
# new in 0.9.1: convert (encode) unicode to ascii # new in 0.9.1: convert (encode) unicode to ascii
self.failUnlessEqual(c_char_p.from_param("123")._obj, b"123") self.assertEqual(c_char_p.from_param("123")._obj, b"123")
self.assertRaises(UnicodeEncodeError, c_char_p.from_param, "123\377") self.assertRaises(UnicodeEncodeError, c_char_p.from_param, "123\377")
self.assertRaises(TypeError, c_char_p.from_param, 42) self.assertRaises(TypeError, c_char_p.from_param, 42)
@ -66,7 +66,7 @@ def test_cstrings(self):
# 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.failUnless(c_char_p.from_param(a) is a) self.assertTrue(c_char_p.from_param(a) is a)
def test_cw_strings(self): def test_cw_strings(self):
from ctypes import byref from ctypes import byref
@ -77,15 +77,15 @@ def test_cw_strings(self):
return return
s = "123" s = "123"
if sys.platform == "win32": if sys.platform == "win32":
self.failUnless(c_wchar_p.from_param(s)._obj is s) self.assertTrue(c_wchar_p.from_param(s)._obj is s)
self.assertRaises(TypeError, c_wchar_p.from_param, 42) self.assertRaises(TypeError, c_wchar_p.from_param, 42)
# new in 0.9.1: convert (decode) ascii to unicode # new in 0.9.1: convert (decode) ascii to unicode
self.failUnlessEqual(c_wchar_p.from_param("123")._obj, "123") self.assertEqual(c_wchar_p.from_param("123")._obj, "123")
self.assertRaises(UnicodeDecodeError, c_wchar_p.from_param, b"123\377") self.assertRaises(UnicodeDecodeError, c_wchar_p.from_param, b"123\377")
pa = c_wchar_p.from_param(c_wchar_p("123")) pa = c_wchar_p.from_param(c_wchar_p("123"))
self.failUnlessEqual(type(pa), c_wchar_p) self.assertEqual(type(pa), c_wchar_p)
def test_int_pointers(self): def test_int_pointers(self):
from ctypes import c_short, c_uint, c_int, c_long, POINTER, pointer from ctypes import c_short, c_uint, c_int, c_long, POINTER, pointer
@ -94,10 +94,10 @@ def test_int_pointers(self):
## p = pointer(c_int(42)) ## p = pointer(c_int(42))
## x = LPINT.from_param(p) ## x = LPINT.from_param(p)
x = LPINT.from_param(pointer(c_int(42))) x = LPINT.from_param(pointer(c_int(42)))
self.failUnlessEqual(x.contents.value, 42) self.assertEqual(x.contents.value, 42)
self.failUnlessEqual(LPINT(c_int(42)).contents.value, 42) self.assertEqual(LPINT(c_int(42)).contents.value, 42)
self.failUnlessEqual(LPINT.from_param(None), 0) self.assertEqual(LPINT.from_param(None), 0)
if c_int != c_long: if c_int != c_long:
self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42))) self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42)))
@ -133,8 +133,8 @@ def test_array_pointers(self):
from ctypes import c_short, c_uint, c_int, c_long, POINTER from ctypes import c_short, c_uint, c_int, c_long, POINTER
INTARRAY = c_int * 3 INTARRAY = c_int * 3
ia = INTARRAY() ia = INTARRAY()
self.failUnlessEqual(len(ia), 3) self.assertEqual(len(ia), 3)
self.failUnlessEqual([ia[i] for i in range(3)], [0, 0, 0]) self.assertEqual([ia[i] for i in range(3)], [0, 0, 0])
# Pointers are only compatible with arrays containing items of # Pointers are only compatible with arrays containing items of
# the same type! # the same type!
@ -161,8 +161,8 @@ def from_param(cls, obj):
return None return None
func.argtypes = (Adapter(),) func.argtypes = (Adapter(),)
self.failUnlessEqual(func(None), None) self.assertEqual(func(None), None)
self.failUnlessEqual(func(object()), None) self.assertEqual(func(object()), None)
class Adapter(object): class Adapter(object):
def from_param(cls, obj): def from_param(cls, obj):
@ -171,7 +171,7 @@ def from_param(cls, obj):
func.argtypes = (Adapter(),) func.argtypes = (Adapter(),)
# don't know how to convert parameter 1 # don't know how to convert parameter 1
self.assertRaises(ArgumentError, func, object()) self.assertRaises(ArgumentError, func, object())
self.failUnlessEqual(func(c_void_p(42)), 42) self.assertEqual(func(c_void_p(42)), 42)
class Adapter(object): class Adapter(object):
def from_param(cls, obj): def from_param(cls, obj):

32
Lib/ctypes/test/test_pep3118.py
View file

@ -24,23 +24,23 @@ def test_native_types(self):
ob = tp() ob = tp()
v = memoryview(ob) v = memoryview(ob)
try: try:
self.failUnlessEqual(normalize(v.format), normalize(fmt)) self.assertEqual(normalize(v.format), normalize(fmt))
if shape is not None: if shape is not None:
self.failUnlessEqual(len(v), shape[0]) self.assertEqual(len(v), shape[0])
else: else:
self.failUnlessEqual(len(v) * sizeof(itemtp), sizeof(ob)) self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
self.failUnlessEqual(v.itemsize, sizeof(itemtp)) self.assertEqual(v.itemsize, sizeof(itemtp))
self.failUnlessEqual(v.shape, shape) self.assertEqual(v.shape, shape)
# ctypes object always have a non-strided memory block # ctypes object always have a non-strided memory block
self.failUnlessEqual(v.strides, None) self.assertEqual(v.strides, None)
# they are always read/write # they are always read/write
self.failIf(v.readonly) self.assertFalse(v.readonly)
if v.shape: if v.shape:
n = 1 n = 1
for dim in v.shape: for dim in v.shape:
n = n * dim n = n * dim
self.failUnlessEqual(n * v.itemsize, len(v.tobytes())) self.assertEqual(n * v.itemsize, len(v.tobytes()))
except: except:
# so that we can see the failing type # so that we can see the failing type
print(tp) print(tp)
@ -51,23 +51,23 @@ def test_endian_types(self):
ob = tp() ob = tp()
v = memoryview(ob) v = memoryview(ob)
try: try:
self.failUnlessEqual(v.format, fmt) self.assertEqual(v.format, fmt)
if shape is not None: if shape is not None:
self.failUnlessEqual(len(v), shape[0]) self.assertEqual(len(v), shape[0])
else: else:
self.failUnlessEqual(len(v) * sizeof(itemtp), sizeof(ob)) self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
self.failUnlessEqual(v.itemsize, sizeof(itemtp)) self.assertEqual(v.itemsize, sizeof(itemtp))
self.failUnlessEqual(v.shape, shape) self.assertEqual(v.shape, shape)
# ctypes object always have a non-strided memory block # ctypes object always have a non-strided memory block
self.failUnlessEqual(v.strides, None) self.assertEqual(v.strides, None)
# they are always read/write # they are always read/write
self.failIf(v.readonly) self.assertFalse(v.readonly)
if v.shape: if v.shape:
n = 1 n = 1
for dim in v.shape: for dim in v.shape:
n = n * dim n = n * dim
self.failUnlessEqual(n, len(v)) self.assertEqual(n, len(v))
except: except:
# so that we can see the failing type # so that we can see the failing type
print(tp) print(tp)

12
Lib/ctypes/test/test_pickling.py
View file

@ -27,8 +27,8 @@ def test_simple(self):
c_double(3.14), c_double(3.14),
]: ]:
dst = self.loads(self.dumps(src)) dst = self.loads(self.dumps(src))
self.failUnlessEqual(src.__dict__, dst.__dict__) self.assertEqual(src.__dict__, dst.__dict__)
self.failUnlessEqual(memoryview(src).tobytes(), self.assertEqual(memoryview(src).tobytes(),
memoryview(dst).tobytes()) memoryview(dst).tobytes())
def test_struct(self): def test_struct(self):
@ -36,17 +36,17 @@ def test_struct(self):
x = X() x = X()
x.a = 42 x.a = 42
self.failUnlessEqual(X.init_called, 1) self.assertEqual(X.init_called, 1)
y = self.loads(self.dumps(x)) y = self.loads(self.dumps(x))
# loads must NOT call __init__ # loads must NOT call __init__
self.failUnlessEqual(X.init_called, 1) self.assertEqual(X.init_called, 1)
# ctypes instances are identical when the instance __dict__ # ctypes instances are identical when the instance __dict__
# and the memory buffer are identical # and the memory buffer are identical
self.failUnlessEqual(y.__dict__, x.__dict__) self.assertEqual(y.__dict__, x.__dict__)
self.failUnlessEqual(memoryview(y).tobytes(), self.assertEqual(memoryview(y).tobytes(),
memoryview(x).tobytes()) memoryview(x).tobytes())
def test_unpickable(self): def test_unpickable(self):

56
Lib/ctypes/test/test_pointers.py
View file

@ -17,7 +17,7 @@ class A(POINTER(c_ulong)):
POINTER(c_ulong)(c_ulong(22)) POINTER(c_ulong)(c_ulong(22))
# Pointer can't set contents: has no _type_ # Pointer can't set contents: has no _type_
self.failUnlessRaises(TypeError, A, c_ulong(33)) self.assertRaises(TypeError, A, c_ulong(33))
def test_pass_pointers(self): def test_pass_pointers(self):
dll = CDLL(_ctypes_test.__file__) dll = CDLL(_ctypes_test.__file__)
@ -27,12 +27,12 @@ def test_pass_pointers(self):
i = c_int(12345678) i = c_int(12345678)
## func.argtypes = (POINTER(c_int),) ## func.argtypes = (POINTER(c_int),)
address = func(byref(i)) address = func(byref(i))
self.failUnlessEqual(c_int.from_address(address).value, 12345678) self.assertEqual(c_int.from_address(address).value, 12345678)
func.restype = POINTER(c_int) func.restype = POINTER(c_int)
res = func(pointer(i)) res = func(pointer(i))
self.failUnlessEqual(res.contents.value, 12345678) self.assertEqual(res.contents.value, 12345678)
self.failUnlessEqual(res[0], 12345678) self.assertEqual(res[0], 12345678)
def test_change_pointers(self): def test_change_pointers(self):
dll = CDLL(_ctypes_test.__file__) dll = CDLL(_ctypes_test.__file__)
@ -43,18 +43,18 @@ def test_change_pointers(self):
func.argtypes = (POINTER(c_int),) func.argtypes = (POINTER(c_int),)
res = func(pointer(i)) res = func(pointer(i))
self.failUnlessEqual(res[0], 87654) self.assertEqual(res[0], 87654)
self.failUnlessEqual(res.contents.value, 87654) self.assertEqual(res.contents.value, 87654)
# C code: *res = 54345 # C code: *res = 54345
res[0] = 54345 res[0] = 54345
self.failUnlessEqual(i.value, 54345) self.assertEqual(i.value, 54345)
# C code: # C code:
# int x = 12321; # int x = 12321;
# res = &x # res = &x
res.contents = c_int(12321) res.contents = c_int(12321)
self.failUnlessEqual(i.value, 54345) self.assertEqual(i.value, 54345)
def test_callbacks_with_pointers(self): def test_callbacks_with_pointers(self):
# a function type receiving a pointer # a function type receiving a pointer
@ -78,7 +78,7 @@ def func(arg):
## i = c_int(42) ## i = c_int(42)
## callback(byref(i)) ## callback(byref(i))
## self.failUnless(i.value == 84) ## self.assertTrue(i.value == 84)
doit(callback) doit(callback)
## print self.result ## print self.result
@ -91,11 +91,11 @@ def test_basics(self):
i = ct(42) i = ct(42)
p = pointer(i) p = pointer(i)
## print type(p.contents), ct ## print type(p.contents), ct
self.failUnless(type(p.contents) is ct) self.assertTrue(type(p.contents) is ct)
# p.contents is the same as p[0] # p.contents is the same as p[0]
## print p.contents ## print p.contents
## self.failUnless(p.contents == 42) ## self.assertTrue(p.contents == 42)
## self.failUnless(p[0] == 42) ## self.assertTrue(p[0] == 42)
self.assertRaises(TypeError, delitem, p, 0) self.assertRaises(TypeError, delitem, p, 0)
@ -117,9 +117,9 @@ class Table(Structure):
pt = pointer(Table(1, 2, 3)) pt = pointer(Table(1, 2, 3))
self.failUnlessEqual(pt.contents.a, 1) self.assertEqual(pt.contents.a, 1)
self.failUnlessEqual(pt.contents.b, 2) self.assertEqual(pt.contents.b, 2)
self.failUnlessEqual(pt.contents.c, 3) self.assertEqual(pt.contents.c, 3)
pt.contents.c = 33 pt.contents.c = 33
@ -130,8 +130,8 @@ def test_basic(self):
p = pointer(c_int(42)) p = pointer(c_int(42))
# Although a pointer can be indexed, it ha no length # Although a pointer can be indexed, it ha no length
self.assertRaises(TypeError, len, p) self.assertRaises(TypeError, len, p)
self.failUnlessEqual(p[0], 42) self.assertEqual(p[0], 42)
self.failUnlessEqual(p.contents.value, 42) self.assertEqual(p.contents.value, 42)
def test_charpp(self): def test_charpp(self):
"""Test that a character pointer-to-pointer is correctly passed""" """Test that a character pointer-to-pointer is correctly passed"""
@ -156,20 +156,20 @@ def test_bug_1467852(self):
pp = pointer(p) pp = pointer(p)
q = pointer(y) q = pointer(y)
pp[0] = q # <== pp[0] = q # <==
self.failUnlessEqual(p[0], 6) self.assertEqual(p[0], 6)
def test_c_void_p(self): def test_c_void_p(self):
# http://sourceforge.net/tracker/?func=detail&aid=1518190&group_id=5470&atid=105470 # http://sourceforge.net/tracker/?func=detail&aid=1518190&group_id=5470&atid=105470
if sizeof(c_void_p) == 4: if sizeof(c_void_p) == 4:
self.failUnlessEqual(c_void_p(0xFFFFFFFF).value, self.assertEqual(c_void_p(0xFFFFFFFF).value,
c_void_p(-1).value) c_void_p(-1).value)
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value, self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
c_void_p(-1).value) c_void_p(-1).value)
elif sizeof(c_void_p) == 8: elif sizeof(c_void_p) == 8:
self.failUnlessEqual(c_void_p(0xFFFFFFFF).value, self.assertEqual(c_void_p(0xFFFFFFFF).value,
0xFFFFFFFF) 0xFFFFFFFF)
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value, self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
c_void_p(-1).value) c_void_p(-1).value)
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value, self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value,
c_void_p(-1).value) c_void_p(-1).value)
self.assertRaises(TypeError, c_void_p, 3.14) # make sure floats are NOT accepted self.assertRaises(TypeError, c_void_p, 3.14) # make sure floats are NOT accepted
@ -177,16 +177,16 @@ def test_c_void_p(self):
def test_pointers_bool(self): def test_pointers_bool(self):
# NULL pointers have a boolean False value, non-NULL pointers True. # NULL pointers have a boolean False value, non-NULL pointers True.
self.failUnlessEqual(bool(POINTER(c_int)()), False) self.assertEqual(bool(POINTER(c_int)()), False)
self.failUnlessEqual(bool(pointer(c_int())), True) self.assertEqual(bool(pointer(c_int())), True)
self.failUnlessEqual(bool(CFUNCTYPE(None)(0)), False) self.assertEqual(bool(CFUNCTYPE(None)(0)), False)
self.failUnlessEqual(bool(CFUNCTYPE(None)(42)), True) self.assertEqual(bool(CFUNCTYPE(None)(42)), True)
# COM methods are boolean True: # COM methods are boolean True:
if sys.platform == "win32": if sys.platform == "win32":
mth = WINFUNCTYPE(None)(42, "name", (), None) mth = WINFUNCTYPE(None)(42, "name", (), None)
self.failUnlessEqual(bool(mth), True) self.assertEqual(bool(mth), True)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

88
Lib/ctypes/test/test_prototypes.py
View file

@ -58,23 +58,23 @@ def test_paramflags(self):
try: try:
func() func()
except TypeError as details: except TypeError as details:
self.failUnlessEqual(str(details), "required argument 'input' missing") self.assertEqual(str(details), "required argument 'input' missing")
else: else:
self.fail("TypeError not raised") self.fail("TypeError not raised")
self.failUnlessEqual(func(None), None) self.assertEqual(func(None), None)
self.failUnlessEqual(func(input=None), None) self.assertEqual(func(input=None), None)
def test_int_pointer_arg(self): def test_int_pointer_arg(self):
func = testdll._testfunc_p_p func = testdll._testfunc_p_p
func.restype = c_long func.restype = c_long
self.failUnlessEqual(0, func(0)) self.assertEqual(0, func(0))
ci = c_int(0) ci = c_int(0)
func.argtypes = POINTER(c_int), func.argtypes = POINTER(c_int),
self.failUnlessEqual(positive_address(addressof(ci)), self.assertEqual(positive_address(addressof(ci)),
positive_address(func(byref(ci)))) positive_address(func(byref(ci))))
func.argtypes = c_char_p, func.argtypes = c_char_p,
@ -91,45 +91,45 @@ def test_POINTER_c_char_arg(self):
func.restype = c_char_p func.restype = c_char_p
func.argtypes = POINTER(c_char), func.argtypes = POINTER(c_char),
self.failUnlessEqual(None, func(None)) self.assertEqual(None, func(None))
self.failUnlessEqual("123", func("123")) self.assertEqual("123", func("123"))
self.failUnlessEqual(None, func(c_char_p(None))) self.assertEqual(None, func(c_char_p(None)))
self.failUnlessEqual("123", func(c_char_p("123"))) self.assertEqual("123", func(c_char_p("123")))
self.failUnlessEqual("123", func(c_buffer("123"))) self.assertEqual("123", func(c_buffer("123")))
ca = c_char("a") ca = c_char("a")
self.failUnlessEqual("a", func(pointer(ca))[0]) self.assertEqual("a", func(pointer(ca))[0])
self.failUnlessEqual("a", func(byref(ca))[0]) self.assertEqual("a", func(byref(ca))[0])
def test_c_char_p_arg(self): def test_c_char_p_arg(self):
func = testdll._testfunc_p_p func = testdll._testfunc_p_p
func.restype = c_char_p func.restype = c_char_p
func.argtypes = c_char_p, func.argtypes = c_char_p,
self.failUnlessEqual(None, func(None)) self.assertEqual(None, func(None))
self.failUnlessEqual("123", func("123")) self.assertEqual("123", func("123"))
self.failUnlessEqual(None, func(c_char_p(None))) self.assertEqual(None, func(c_char_p(None)))
self.failUnlessEqual("123", func(c_char_p("123"))) self.assertEqual("123", func(c_char_p("123")))
self.failUnlessEqual("123", func(c_buffer("123"))) self.assertEqual("123", func(c_buffer("123")))
ca = c_char("a") ca = c_char("a")
self.failUnlessEqual("a", func(pointer(ca))[0]) self.assertEqual("a", func(pointer(ca))[0])
self.failUnlessEqual("a", func(byref(ca))[0]) self.assertEqual("a", func(byref(ca))[0])
def test_c_void_p_arg(self): def test_c_void_p_arg(self):
func = testdll._testfunc_p_p func = testdll._testfunc_p_p
func.restype = c_char_p func.restype = c_char_p
func.argtypes = c_void_p, func.argtypes = c_void_p,
self.failUnlessEqual(None, func(None)) self.assertEqual(None, func(None))
self.failUnlessEqual("123", func(b"123")) self.assertEqual("123", func(b"123"))
self.failUnlessEqual("123", func(c_char_p("123"))) self.assertEqual("123", func(c_char_p("123")))
self.failUnlessEqual(None, func(c_char_p(None))) self.assertEqual(None, func(c_char_p(None)))
self.failUnlessEqual("123", func(c_buffer("123"))) self.assertEqual("123", func(c_buffer("123")))
ca = c_char("a") ca = c_char("a")
self.failUnlessEqual("a", func(pointer(ca))[0]) self.assertEqual("a", func(pointer(ca))[0])
self.failUnlessEqual("a", func(byref(ca))[0]) self.assertEqual("a", func(byref(ca))[0])
func(byref(c_int())) func(byref(c_int()))
func(pointer(c_int())) func(pointer(c_int()))
@ -140,8 +140,8 @@ def test_c_void_p_arg(self):
except NameError: except NameError:
pass pass
else: else:
self.failUnlessEqual(None, func(c_wchar_p(None))) self.assertEqual(None, func(c_wchar_p(None)))
self.failUnlessEqual("123", func(c_wchar_p("123"))) self.assertEqual("123", func(c_wchar_p("123")))
def test_instance(self): def test_instance(self):
func = testdll._testfunc_p_p func = testdll._testfunc_p_p
@ -151,10 +151,10 @@ class X:
_as_parameter_ = None _as_parameter_ = None
func.argtypes = c_void_p, func.argtypes = c_void_p,
self.failUnlessEqual(None, func(X())) self.assertEqual(None, func(X()))
func.argtypes = None func.argtypes = None
self.failUnlessEqual(None, func(X())) self.assertEqual(None, func(X()))
try: try:
c_wchar c_wchar
@ -174,15 +174,15 @@ def test_POINTER_c_wchar_arg(self):
func.restype = c_wchar_p func.restype = c_wchar_p
func.argtypes = POINTER(c_wchar), func.argtypes = POINTER(c_wchar),
self.failUnlessEqual(None, func(None)) self.assertEqual(None, func(None))
self.failUnlessEqual("123", func("123")) self.assertEqual("123", func("123"))
self.failUnlessEqual(None, func(c_wchar_p(None))) self.assertEqual(None, func(c_wchar_p(None)))
self.failUnlessEqual("123", func(c_wchar_p("123"))) self.assertEqual("123", func(c_wchar_p("123")))
self.failUnlessEqual("123", func(c_wbuffer("123"))) self.assertEqual("123", func(c_wbuffer("123")))
ca = c_wchar("a") ca = c_wchar("a")
self.failUnlessEqual("a", func(pointer(ca))[0]) self.assertEqual("a", func(pointer(ca))[0])
self.failUnlessEqual("a", func(byref(ca))[0]) self.assertEqual("a", func(byref(ca))[0])
def test_c_wchar_p_arg(self): def test_c_wchar_p_arg(self):
func = testdll._testfunc_p_p func = testdll._testfunc_p_p
@ -191,16 +191,16 @@ def test_c_wchar_p_arg(self):
c_wchar_p.from_param("123") c_wchar_p.from_param("123")
self.failUnlessEqual(None, func(None)) self.assertEqual(None, func(None))
self.failUnlessEqual("123", func("123")) self.assertEqual("123", func("123"))
self.failUnlessEqual(None, func(c_wchar_p(None))) self.assertEqual(None, func(c_wchar_p(None)))
self.failUnlessEqual("123", func(c_wchar_p("123"))) self.assertEqual("123", func(c_wchar_p("123")))
# XXX Currently, these raise TypeErrors, although they shouldn't: # XXX Currently, these raise TypeErrors, although they shouldn't:
self.failUnlessEqual("123", func(c_wbuffer("123"))) self.assertEqual("123", func(c_wbuffer("123")))
ca = c_wchar("a") ca = c_wchar("a")
self.failUnlessEqual("a", func(pointer(ca))[0]) self.assertEqual("a", func(pointer(ca))[0])
self.failUnlessEqual("a", func(byref(ca))[0]) self.assertEqual("a", func(byref(ca))[0])
class ArrayTest(unittest.TestCase): class ArrayTest(unittest.TestCase):
def test(self): def test(self):

34
Lib/ctypes/test/test_python_api.py
View file

@ -23,7 +23,7 @@ def test_PyBytes_FromStringAndSize(self):
PyBytes_FromStringAndSize.restype = py_object PyBytes_FromStringAndSize.restype = py_object
PyBytes_FromStringAndSize.argtypes = c_char_p, c_py_ssize_t PyBytes_FromStringAndSize.argtypes = c_char_p, c_py_ssize_t
self.failUnlessEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc") self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
def test_PyString_FromString(self): def test_PyString_FromString(self):
pythonapi.PyBytes_FromString.restype = py_object pythonapi.PyBytes_FromString.restype = py_object
@ -32,10 +32,10 @@ def test_PyString_FromString(self):
s = b"abc" s = b"abc"
refcnt = grc(s) refcnt = grc(s)
pyob = pythonapi.PyBytes_FromString(s) pyob = pythonapi.PyBytes_FromString(s)
self.failUnlessEqual(grc(s), refcnt) self.assertEqual(grc(s), refcnt)
self.failUnlessEqual(s, pyob) self.assertEqual(s, pyob)
del pyob del pyob
self.failUnlessEqual(grc(s), refcnt) self.assertEqual(grc(s), refcnt)
if is_resource_enabled("refcount"): if is_resource_enabled("refcount"):
# This test is unreliable, because it is possible that code in # This test is unreliable, because it is possible that code in
@ -44,28 +44,28 @@ def test_PyString_FromString(self):
def test_PyLong_Long(self): def test_PyLong_Long(self):
ref42 = grc(42) ref42 = grc(42)
pythonapi.PyLong_FromLong.restype = py_object pythonapi.PyLong_FromLong.restype = py_object
self.failUnlessEqual(pythonapi.PyLong_FromLong(42), 42) self.assertEqual(pythonapi.PyLong_FromLong(42), 42)
self.failUnlessEqual(grc(42), ref42) self.assertEqual(grc(42), ref42)
pythonapi.PyLong_AsLong.argtypes = (py_object,) pythonapi.PyLong_AsLong.argtypes = (py_object,)
pythonapi.PyLong_AsLong.restype = c_long pythonapi.PyLong_AsLong.restype = c_long
res = pythonapi.PyLong_AsLong(42) res = pythonapi.PyLong_AsLong(42)
self.failUnlessEqual(grc(res), ref42 + 1) self.assertEqual(grc(res), ref42 + 1)
del res del res
self.failUnlessEqual(grc(42), ref42) self.assertEqual(grc(42), ref42)
def test_PyObj_FromPtr(self): def test_PyObj_FromPtr(self):
s = "abc def ghi jkl" s = "abc def ghi jkl"
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.failUnless(s is pyobj) self.assertTrue(s is pyobj)
self.failUnlessEqual(grc(s), ref + 1) self.assertEqual(grc(s), ref + 1)
del pyobj del pyobj
self.failUnlessEqual(grc(s), ref) self.assertEqual(grc(s), ref)
def test_PyOS_snprintf(self): def test_PyOS_snprintf(self):
PyOS_snprintf = pythonapi.PyOS_snprintf PyOS_snprintf = pythonapi.PyOS_snprintf
@ -73,18 +73,18 @@ def test_PyOS_snprintf(self):
buf = c_buffer(256) buf = c_buffer(256)
PyOS_snprintf(buf, sizeof(buf), "Hello from %s", b"ctypes") PyOS_snprintf(buf, sizeof(buf), "Hello from %s", b"ctypes")
self.failUnlessEqual(buf.value, b"Hello from ctypes") self.assertEqual(buf.value, b"Hello from ctypes")
PyOS_snprintf(buf, sizeof(buf), "Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3) PyOS_snprintf(buf, sizeof(buf), "Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3)
self.failUnlessEqual(buf.value, b"Hello from ctypes (1, 2, 3)") self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
# not enough arguments # not enough arguments
self.failUnlessRaises(TypeError, PyOS_snprintf, buf) self.assertRaises(TypeError, PyOS_snprintf, buf)
def test_pyobject_repr(self): def test_pyobject_repr(self):
self.failUnlessEqual(repr(py_object()), "py_object(<NULL>)") self.assertEqual(repr(py_object()), "py_object(<NULL>)")
self.failUnlessEqual(repr(py_object(42)), "py_object(42)") self.assertEqual(repr(py_object(42)), "py_object(42)")
self.failUnlessEqual(repr(py_object(object)), "py_object(%r)" % object) self.assertEqual(repr(py_object(object)), "py_object(%r)" % object)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

10
Lib/ctypes/test/test_random_things.py
View file

@ -20,7 +20,7 @@ def test(self):
hdll = windll.kernel32.LoadLibraryA(b"kernel32") hdll = windll.kernel32.LoadLibraryA(b"kernel32")
funcaddr = windll.kernel32.GetProcAddress(hdll, "GetModuleHandleA") funcaddr = windll.kernel32.GetProcAddress(hdll, "GetModuleHandleA")
self.failUnlessEqual(call_function(funcaddr, (None,)), self.assertEqual(call_function(funcaddr, (None,)),
windll.kernel32.GetModuleHandleA(None)) windll.kernel32.GetModuleHandleA(None))
class CallbackTracbackTestCase(unittest.TestCase): class CallbackTracbackTestCase(unittest.TestCase):
@ -49,25 +49,25 @@ def capture_stderr(self, func, *args, **kw):
def test_ValueError(self): def test_ValueError(self):
cb = CFUNCTYPE(c_int, c_int)(callback_func) cb = CFUNCTYPE(c_int, c_int)(callback_func)
out = self.capture_stderr(cb, 42) out = self.capture_stderr(cb, 42)
self.failUnlessEqual(out.splitlines()[-1], self.assertEqual(out.splitlines()[-1],
"ValueError: 42") "ValueError: 42")
def test_IntegerDivisionError(self): def test_IntegerDivisionError(self):
cb = CFUNCTYPE(c_int, c_int)(callback_func) cb = CFUNCTYPE(c_int, c_int)(callback_func)
out = self.capture_stderr(cb, 0) out = self.capture_stderr(cb, 0)
self.failUnlessEqual(out.splitlines()[-1][:19], self.assertEqual(out.splitlines()[-1][:19],
"ZeroDivisionError: ") "ZeroDivisionError: ")
def test_FloatDivisionError(self): def test_FloatDivisionError(self):
cb = CFUNCTYPE(c_int, c_double)(callback_func) cb = CFUNCTYPE(c_int, c_double)(callback_func)
out = self.capture_stderr(cb, 0.0) out = self.capture_stderr(cb, 0.0)
self.failUnlessEqual(out.splitlines()[-1][:19], self.assertEqual(out.splitlines()[-1][:19],
"ZeroDivisionError: ") "ZeroDivisionError: ")
def test_TypeErrorDivisionError(self): def test_TypeErrorDivisionError(self):
cb = CFUNCTYPE(c_int, c_char_p)(callback_func) cb = CFUNCTYPE(c_int, c_char_p)(callback_func)
out = self.capture_stderr(cb, "spam") out = self.capture_stderr(cb, "spam")
self.failUnlessEqual(out.splitlines()[-1], self.assertEqual(out.splitlines()[-1],
"TypeError: " "TypeError: "
"unsupported operand type(s) for /: 'int' and 'str'") "unsupported operand type(s) for /: 'int' and 'str'")

28
Lib/ctypes/test/test_refcounts.py
View file

@ -21,17 +21,17 @@ def callback(value):
#print "called back with", value #print "called back with", value
return value return value
self.failUnlessEqual(grc(callback), 2) self.assertEqual(grc(callback), 2)
cb = MyCallback(callback) cb = MyCallback(callback)
self.failUnless(grc(callback) > 2) self.assertTrue(grc(callback) > 2)
result = f(-10, cb) result = f(-10, cb)
self.failUnlessEqual(result, -18) self.assertEqual(result, -18)
cb = None cb = None
gc.collect() gc.collect()
self.failUnlessEqual(grc(callback), 2) self.assertEqual(grc(callback), 2)
def test_refcount(self): def test_refcount(self):
@ -39,19 +39,19 @@ def test_refcount(self):
def func(*args): def func(*args):
pass pass
# this is the standard refcount for func # this is the standard refcount for func
self.failUnlessEqual(grc(func), 2) self.assertEqual(grc(func), 2)
# the CFuncPtr instance holds atr least one refcount on func: # the CFuncPtr instance holds atr least one refcount on func:
f = OtherCallback(func) f = OtherCallback(func)
self.failUnless(grc(func) > 2) self.assertTrue(grc(func) > 2)
# and may release it again # and may release it again
del f del f
self.failUnless(grc(func) >= 2) self.assertTrue(grc(func) >= 2)
# but now it must be gone # but now it must be gone
gc.collect() gc.collect()
self.failUnless(grc(func) == 2) self.assertTrue(grc(func) == 2)
class X(ctypes.Structure): class X(ctypes.Structure):
_fields_ = [("a", OtherCallback)] _fields_ = [("a", OtherCallback)]
@ -59,27 +59,27 @@ class X(ctypes.Structure):
x.a = OtherCallback(func) x.a = OtherCallback(func)
# the CFuncPtr instance holds atr least one refcount on func: # the CFuncPtr instance holds atr least one refcount on func:
self.failUnless(grc(func) > 2) self.assertTrue(grc(func) > 2)
# and may release it again # and may release it again
del x del x
self.failUnless(grc(func) >= 2) self.assertTrue(grc(func) >= 2)
# and now it must be gone again # and now it must be gone again
gc.collect() gc.collect()
self.failUnlessEqual(grc(func), 2) self.assertEqual(grc(func), 2)
f = OtherCallback(func) f = OtherCallback(func)
# the CFuncPtr instance holds atr least one refcount on func: # the CFuncPtr instance holds atr least one refcount on func:
self.failUnless(grc(func) > 2) self.assertTrue(grc(func) > 2)
# create a cycle # create a cycle
f.cycle = f f.cycle = f
del f del f
gc.collect() gc.collect()
self.failUnlessEqual(grc(func), 2) self.assertEqual(grc(func), 2)
class AnotherLeak(unittest.TestCase): class AnotherLeak(unittest.TestCase):
def test_callback(self): def test_callback(self):
@ -92,7 +92,7 @@ def func(a, b):
a = sys.getrefcount(ctypes.c_int) a = sys.getrefcount(ctypes.c_int)
f(1, 2) f(1, 2)
self.failUnlessEqual(sys.getrefcount(ctypes.c_int), a) self.assertEqual(sys.getrefcount(ctypes.c_int), a)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

8
Lib/ctypes/test/test_repr.py
View file

@ -18,12 +18,12 @@ class ReprTest(unittest.TestCase):
def test_numbers(self): def test_numbers(self):
for typ in subclasses: for typ in subclasses:
base = typ.__bases__[0] base = typ.__bases__[0]
self.failUnless(repr(base(42)).startswith(base.__name__)) self.assertTrue(repr(base(42)).startswith(base.__name__))
self.failUnlessEqual("<X object at", repr(typ(42))[:12]) self.assertEqual("<X object at", repr(typ(42))[:12])
def test_char(self): def test_char(self):
self.failUnlessEqual("c_char(b'x')", repr(c_char('x'))) self.assertEqual("c_char(b'x')", repr(c_char('x')))
self.failUnlessEqual("<X object at", repr(X('x'))[:12]) self.assertEqual("<X object at", repr(X('x'))[:12])
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

12
Lib/ctypes/test/test_returnfuncptrs.py
View file

@ -12,10 +12,10 @@ def test_with_prototype(self):
get_strchr = dll.get_strchr get_strchr = dll.get_strchr
get_strchr.restype = CFUNCTYPE(c_char_p, c_char_p, c_char) get_strchr.restype = CFUNCTYPE(c_char_p, c_char_p, c_char)
strchr = get_strchr() strchr = get_strchr()
self.failUnlessEqual(strchr("abcdef", "b"), "bcdef") self.assertEqual(strchr("abcdef", "b"), "bcdef")
self.failUnlessEqual(strchr("abcdef", "x"), None) self.assertEqual(strchr("abcdef", "x"), None)
self.failUnlessEqual(strchr("abcdef", 98), "bcdef") self.assertEqual(strchr("abcdef", 98), "bcdef")
self.failUnlessEqual(strchr("abcdef", 107), None) self.assertEqual(strchr("abcdef", 107), None)
self.assertRaises(ArgumentError, strchr, "abcdef", 3.0) self.assertRaises(ArgumentError, strchr, "abcdef", 3.0)
self.assertRaises(TypeError, strchr, "abcdef") self.assertRaises(TypeError, strchr, "abcdef")
@ -28,8 +28,8 @@ def test_without_prototype(self):
# _CFuncPtr instances are now callable with an integer argument # _CFuncPtr instances are now callable with an integer argument
# which denotes a function address: # which denotes a function address:
strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(addr) strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(addr)
self.failUnless(strchr("abcdef", "b"), "bcdef") self.assertTrue(strchr("abcdef", "b"), "bcdef")
self.failUnlessEqual(strchr("abcdef", "x"), None) self.assertEqual(strchr("abcdef", "x"), None)
self.assertRaises(ArgumentError, strchr, "abcdef", 3.0) self.assertRaises(ArgumentError, strchr, "abcdef", 3.0)
self.assertRaises(TypeError, strchr, "abcdef") self.assertRaises(TypeError, strchr, "abcdef")

18
Lib/ctypes/test/test_simplesubclasses.py
View file

@ -10,8 +10,8 @@ def __eq__(self, other):
class Test(unittest.TestCase): class Test(unittest.TestCase):
def test_compare(self): def test_compare(self):
self.failUnlessEqual(MyInt(3), MyInt(3)) self.assertEqual(MyInt(3), MyInt(3))
self.failIfEqual(MyInt(42), MyInt(43)) self.assertNotEqual(MyInt(42), MyInt(43))
def test_ignore_retval(self): def test_ignore_retval(self):
# Test if the return value of a callback is ignored # Test if the return value of a callback is ignored
@ -21,7 +21,7 @@ def func():
return (1, "abc", None) return (1, "abc", None)
cb = proto(func) cb = proto(func)
self.failUnlessEqual(None, cb()) self.assertEqual(None, cb())
def test_int_callback(self): def test_int_callback(self):
@ -32,24 +32,24 @@ def func(arg):
cb = CFUNCTYPE(None, MyInt)(func) cb = CFUNCTYPE(None, MyInt)(func)
self.failUnlessEqual(None, cb(42)) self.assertEqual(None, cb(42))
self.failUnlessEqual(type(args[-1]), MyInt) self.assertEqual(type(args[-1]), MyInt)
cb = CFUNCTYPE(c_int, c_int)(func) cb = CFUNCTYPE(c_int, c_int)(func)
self.failUnlessEqual(42, cb(42)) self.assertEqual(42, cb(42))
self.failUnlessEqual(type(args[-1]), int) self.assertEqual(type(args[-1]), int)
def test_int_struct(self): def test_int_struct(self):
class X(Structure): class X(Structure):
_fields_ = [("x", MyInt)] _fields_ = [("x", MyInt)]
self.failUnlessEqual(X().x, MyInt()) self.assertEqual(X().x, MyInt())
s = X() s = X()
s.x = MyInt(42) s.x = MyInt(42)
self.failUnlessEqual(s.x, MyInt(42)) self.assertEqual(s.x, MyInt(42))
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

18
Lib/ctypes/test/test_sizes.py
View file

@ -5,23 +5,23 @@
class SizesTestCase(unittest.TestCase): class SizesTestCase(unittest.TestCase):
def test_8(self): def test_8(self):
self.failUnlessEqual(1, sizeof(c_int8)) self.assertEqual(1, sizeof(c_int8))
self.failUnlessEqual(1, sizeof(c_uint8)) self.assertEqual(1, sizeof(c_uint8))
def test_16(self): def test_16(self):
self.failUnlessEqual(2, sizeof(c_int16)) self.assertEqual(2, sizeof(c_int16))
self.failUnlessEqual(2, sizeof(c_uint16)) self.assertEqual(2, sizeof(c_uint16))
def test_32(self): def test_32(self):
self.failUnlessEqual(4, sizeof(c_int32)) self.assertEqual(4, sizeof(c_int32))
self.failUnlessEqual(4, sizeof(c_uint32)) self.assertEqual(4, sizeof(c_uint32))
def test_64(self): def test_64(self):
self.failUnlessEqual(8, sizeof(c_int64)) self.assertEqual(8, sizeof(c_int64))
self.failUnlessEqual(8, sizeof(c_uint64)) self.assertEqual(8, sizeof(c_uint64))
def test_size_t(self): def test_size_t(self):
self.failUnlessEqual(sizeof(c_void_p), sizeof(c_size_t)) self.assertEqual(sizeof(c_void_p), sizeof(c_size_t))
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

86
Lib/ctypes/test/test_slicing.py
View file

@ -7,43 +7,43 @@ class SlicesTestCase(unittest.TestCase):
def test_getslice_cint(self): def test_getslice_cint(self):
a = (c_int * 100)(*range(1100, 1200)) a = (c_int * 100)(*range(1100, 1200))
b = list(range(1100, 1200)) b = list(range(1100, 1200))
self.failUnlessEqual(a[0:2], b[0:2]) self.assertEqual(a[0:2], b[0:2])
self.failUnlessEqual(a[0:2:], b[0:2:]) self.assertEqual(a[0:2:], b[0:2:])
self.failUnlessEqual(len(a), len(b)) self.assertEqual(len(a), len(b))
self.failUnlessEqual(a[5:7], b[5:7]) self.assertEqual(a[5:7], b[5:7])
self.failUnlessEqual(a[5:7:], b[5:7:]) self.assertEqual(a[5:7:], b[5:7:])
self.failUnlessEqual(a[-1], b[-1]) self.assertEqual(a[-1], b[-1])
self.failUnlessEqual(a[:], b[:]) self.assertEqual(a[:], b[:])
self.failUnlessEqual(a[::], b[::]) self.assertEqual(a[::], b[::])
self.failUnlessEqual(a[10::-1], b[10::-1]) self.assertEqual(a[10::-1], b[10::-1])
self.failUnlessEqual(a[30:20:-1], b[30:20:-1]) self.assertEqual(a[30:20:-1], b[30:20:-1])
self.failUnlessEqual(a[:12:6], b[:12:6]) self.assertEqual(a[:12:6], b[:12:6])
self.failUnlessEqual(a[2:6:4], b[2:6:4]) self.assertEqual(a[2:6:4], b[2:6:4])
a[0:5] = range(5, 10) a[0:5] = range(5, 10)
self.failUnlessEqual(a[0:5], list(range(5, 10))) self.assertEqual(a[0:5], list(range(5, 10)))
self.failUnlessEqual(a[0:5:], list(range(5, 10))) self.assertEqual(a[0:5:], list(range(5, 10)))
self.failUnlessEqual(a[4::-1], list(range(9, 4, -1))) self.assertEqual(a[4::-1], list(range(9, 4, -1)))
def test_setslice_cint(self): def test_setslice_cint(self):
a = (c_int * 100)(*range(1100, 1200)) a = (c_int * 100)(*range(1100, 1200))
b = list(range(1100, 1200)) b = list(range(1100, 1200))
a[32:47] = list(range(32, 47)) a[32:47] = list(range(32, 47))
self.failUnlessEqual(a[32:47], list(range(32, 47))) self.assertEqual(a[32:47], list(range(32, 47)))
a[32:47] = range(132, 147) a[32:47] = range(132, 147)
self.failUnlessEqual(a[32:47:], list(range(132, 147))) self.assertEqual(a[32:47:], list(range(132, 147)))
a[46:31:-1] = range(232, 247) a[46:31:-1] = range(232, 247)
self.failUnlessEqual(a[32:47:1], list(range(246, 231, -1))) self.assertEqual(a[32:47:1], list(range(246, 231, -1)))
a[32:47] = range(1132, 1147) a[32:47] = range(1132, 1147)
self.failUnlessEqual(a[:], b) self.assertEqual(a[:], b)
a[32:47:7] = range(3) a[32:47:7] = range(3)
b[32:47:7] = range(3) b[32:47:7] = range(3)
self.failUnlessEqual(a[:], b) self.assertEqual(a[:], b)
a[33::-3] = range(12) a[33::-3] = range(12)
b[33::-3] = range(12) b[33::-3] = range(12)
self.failUnlessEqual(a[:], b) self.assertEqual(a[:], b)
from operator import setitem from operator import setitem
@ -65,12 +65,12 @@ def test_char_ptr(self):
dll.my_strdup.restype = POINTER(c_char) dll.my_strdup.restype = POINTER(c_char)
dll.my_free.restype = None dll.my_free.restype = None
res = dll.my_strdup(s) res = dll.my_strdup(s)
self.failUnlessEqual(res[:len(s)], s) self.assertEqual(res[:len(s)], s)
self.failUnlessEqual(res[:3], s[:3]) self.assertEqual(res[:3], s[:3])
self.failUnlessEqual(res[:len(s):], s) self.assertEqual(res[:len(s):], s)
self.failUnlessEqual(res[len(s)-1:-1:-1], s[::-1]) self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
self.failUnlessEqual(res[len(s)-1:5:-7], s[:5:-7]) self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
self.failUnlessEqual(res[0:-1:-1], s[0::-1]) self.assertEqual(res[0:-1:-1], s[0::-1])
import operator import operator
self.assertRaises(ValueError, operator.getitem, self.assertRaises(ValueError, operator.getitem,
@ -88,8 +88,8 @@ def test_char_ptr(self):
dll.my_strdup.restype = POINTER(c_byte) dll.my_strdup.restype = POINTER(c_byte)
res = dll.my_strdup(s) res = dll.my_strdup(s)
self.failUnlessEqual(res[:len(s)], list(range(ord("a"), ord("z")+1))) self.assertEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
self.failUnlessEqual(res[:len(s):], list(range(ord("a"), ord("z")+1))) self.assertEqual(res[:len(s):], list(range(ord("a"), ord("z")+1)))
dll.my_free(res) dll.my_free(res)
def test_char_ptr_with_free(self): def test_char_ptr_with_free(self):
@ -109,7 +109,7 @@ def errcheck(result, func, args):
dll.my_strdup.errcheck = errcheck dll.my_strdup.errcheck = errcheck
try: try:
res = dll.my_strdup(s) res = dll.my_strdup(s)
self.failUnlessEqual(res, s.decode()) self.assertEqual(res, s.decode())
finally: finally:
del dll.my_strdup.errcheck del dll.my_strdup.errcheck
@ -118,11 +118,11 @@ def test_char_array(self):
s = b"abcdefghijklmnopqrstuvwxyz\0" s = b"abcdefghijklmnopqrstuvwxyz\0"
p = (c_char * 27)(*s) p = (c_char * 27)(*s)
self.failUnlessEqual(p[:], s) self.assertEqual(p[:], s)
self.failUnlessEqual(p[::], s) self.assertEqual(p[::], s)
self.failUnlessEqual(p[::-1], s[::-1]) self.assertEqual(p[::-1], s[::-1])
self.failUnlessEqual(p[5::-2], s[5::-2]) self.assertEqual(p[5::-2], s[5::-2])
self.failUnlessEqual(p[2:5:-3], s[2:5:-3]) self.assertEqual(p[2:5:-3], s[2:5:-3])
try: try:
@ -138,10 +138,10 @@ def test_wchar_ptr(self):
dll.my_wcsdup.argtypes = POINTER(c_wchar), dll.my_wcsdup.argtypes = POINTER(c_wchar),
dll.my_free.restype = None dll.my_free.restype = None
res = dll.my_wcsdup(s) res = dll.my_wcsdup(s)
self.failUnlessEqual(res[:len(s)], s) self.assertEqual(res[:len(s)], s)
self.failUnlessEqual(res[:len(s):], s) self.assertEqual(res[:len(s):], s)
self.failUnlessEqual(res[len(s)-1:-1:-1], s[::-1]) self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
self.failUnlessEqual(res[len(s)-1:5:-7], s[:5:-7]) self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
import operator import operator
self.assertRaises(TypeError, operator.setitem, self.assertRaises(TypeError, operator.setitem,
@ -158,10 +158,10 @@ def test_wchar_ptr(self):
return return
res = dll.my_wcsdup(s) res = dll.my_wcsdup(s)
tmpl = list(range(ord("a"), ord("z")+1)) tmpl = list(range(ord("a"), ord("z")+1))
self.failUnlessEqual(res[:len(s)-1], tmpl) self.assertEqual(res[:len(s)-1], tmpl)
self.failUnlessEqual(res[:len(s)-1:], tmpl) self.assertEqual(res[:len(s)-1:], tmpl)
self.failUnlessEqual(res[len(s)-2:-1:-1], tmpl[::-1]) self.assertEqual(res[len(s)-2:-1:-1], tmpl[::-1])
self.failUnlessEqual(res[len(s)-2:5:-7], tmpl[:5:-7]) self.assertEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
dll.my_free(res) dll.my_free(res)
################################################################ ################################################################

22
Lib/ctypes/test/test_stringptr.py
View file

@ -16,14 +16,14 @@ class X(Structure):
self.assertRaises(ValueError, getattr, x.str, "contents") self.assertRaises(ValueError, getattr, x.str, "contents")
b = c_buffer("Hello, World") b = c_buffer("Hello, World")
from sys import getrefcount as grc from sys import getrefcount as grc
self.failUnlessEqual(grc(b), 2) self.assertEqual(grc(b), 2)
x.str = b x.str = b
self.failUnlessEqual(grc(b), 3) self.assertEqual(grc(b), 3)
# POINTER(c_char) and Python string is NOT compatible # POINTER(c_char) and Python string is NOT compatible
# POINTER(c_char) and c_buffer() is compatible # POINTER(c_char) and c_buffer() is compatible
for i in range(len(b)): for i in range(len(b)):
self.failUnlessEqual(b[i], x.str[i]) self.assertEqual(b[i], x.str[i])
self.assertRaises(TypeError, setattr, x, "str", "Hello, World") self.assertRaises(TypeError, setattr, x, "str", "Hello, World")
@ -34,11 +34,11 @@ class X(Structure):
# c_char_p and Python string is compatible # c_char_p and Python string is compatible
# c_char_p and c_buffer is NOT compatible # c_char_p and c_buffer is NOT compatible
self.failUnlessEqual(x.str, None) self.assertEqual(x.str, None)
x.str = "Hello, World" x.str = "Hello, World"
self.failUnlessEqual(x.str, "Hello, World") self.assertEqual(x.str, "Hello, World")
b = c_buffer("Hello, World") b = c_buffer("Hello, World")
self.failUnlessRaises(TypeError, setattr, x, "str", b) self.assertRaises(TypeError, setattr, x, "str", b)
def test_functions(self): def test_functions(self):
@ -48,15 +48,15 @@ def test_functions(self):
# c_char_p and Python string is compatible # c_char_p and Python string is compatible
# c_char_p and c_buffer are now compatible # c_char_p and c_buffer are now compatible
strchr.argtypes = c_char_p, c_char strchr.argtypes = c_char_p, c_char
self.failUnlessEqual(strchr("abcdef", "c"), "cdef") self.assertEqual(strchr("abcdef", "c"), "cdef")
self.failUnlessEqual(strchr(c_buffer("abcdef"), "c"), "cdef") self.assertEqual(strchr(c_buffer("abcdef"), "c"), "cdef")
# POINTER(c_char) and Python string is NOT compatible # POINTER(c_char) and Python string is NOT compatible
# POINTER(c_char) and c_buffer() is compatible # POINTER(c_char) and c_buffer() is compatible
strchr.argtypes = POINTER(c_char), c_char strchr.argtypes = POINTER(c_char), c_char
buf = c_buffer("abcdef") buf = c_buffer("abcdef")
self.failUnlessEqual(strchr(buf, "c"), "cdef") self.assertEqual(strchr(buf, "c"), "cdef")
self.failUnlessEqual(strchr("abcdef", "c"), "cdef") self.assertEqual(strchr("abcdef", "c"), "cdef")
# XXX These calls are dangerous, because the first argument # XXX These calls are dangerous, because the first argument
# to strchr is no longer valid after the function returns! # to strchr is no longer valid after the function returns!
@ -66,7 +66,7 @@ def test_functions(self):
buf = c_buffer("abcdef") buf = c_buffer("abcdef")
r = strchr(buf, "c") r = strchr(buf, "c")
x = r[0], r[1], r[2], r[3], r[4] x = r[0], r[1], r[2], r[3], r[4]
self.failUnlessEqual(x, (b"c", b"d", b"e", b"f", b"\000")) self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
del buf del buf
# x1 will NOT be the same as x, usually: # x1 will NOT be the same as x, usually:
x1 = r[0], r[1], r[2], r[3], r[4] x1 = r[0], r[1], r[2], r[3], r[4]

86
Lib/ctypes/test/test_strings.py
View file

@ -6,20 +6,20 @@ def test(self):
BUF = c_char * 4 BUF = c_char * 4
buf = BUF("a", "b", "c") buf = BUF("a", "b", "c")
self.failUnlessEqual(buf.value, b"abc") self.assertEqual(buf.value, b"abc")
self.failUnlessEqual(buf.raw, b"abc\000") self.assertEqual(buf.raw, b"abc\000")
buf.value = "ABCD" buf.value = "ABCD"
self.failUnlessEqual(buf.value, b"ABCD") self.assertEqual(buf.value, b"ABCD")
self.failUnlessEqual(buf.raw, b"ABCD") self.assertEqual(buf.raw, b"ABCD")
buf.value = "x" buf.value = "x"
self.failUnlessEqual(buf.value, b"x") self.assertEqual(buf.value, b"x")
self.failUnlessEqual(buf.raw, b"x\000CD") self.assertEqual(buf.raw, b"x\000CD")
buf[1] = "Z" buf[1] = "Z"
self.failUnlessEqual(buf.value, b"xZCD") self.assertEqual(buf.value, b"xZCD")
self.failUnlessEqual(buf.raw, b"xZCD") self.assertEqual(buf.raw, b"xZCD")
self.assertRaises(ValueError, setattr, buf, "value", "aaaaaaaa") self.assertRaises(ValueError, setattr, buf, "value", "aaaaaaaa")
self.assertRaises(TypeError, setattr, buf, "value", 42) self.assertRaises(TypeError, setattr, buf, "value", 42)
@ -28,9 +28,9 @@ def test_c_buffer_value(self):
buf = c_buffer(32) buf = c_buffer(32)
buf.value = b"Hello, World" buf.value = b"Hello, World"
self.failUnlessEqual(buf.value, b"Hello, World") self.assertEqual(buf.value, b"Hello, World")
self.failUnlessRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World")) self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc")) self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100)) self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
@ -38,7 +38,7 @@ def test_c_buffer_raw(self):
buf = c_buffer(32) buf = c_buffer(32)
buf.raw = memoryview(b"Hello, World") buf.raw = memoryview(b"Hello, World")
self.failUnlessEqual(buf.value, b"Hello, World") self.assertEqual(buf.value, b"Hello, World")
self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc")) self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100)) self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
@ -63,16 +63,16 @@ def test(self):
BUF = c_wchar * 4 BUF = c_wchar * 4
buf = BUF("a", "b", "c") buf = BUF("a", "b", "c")
self.failUnlessEqual(buf.value, "abc") self.assertEqual(buf.value, "abc")
buf.value = "ABCD" buf.value = "ABCD"
self.failUnlessEqual(buf.value, "ABCD") self.assertEqual(buf.value, "ABCD")
buf.value = "x" buf.value = "x"
self.failUnlessEqual(buf.value, "x") self.assertEqual(buf.value, "x")
buf[1] = "Z" buf[1] = "Z"
self.failUnlessEqual(buf.value, "xZCD") self.assertEqual(buf.value, "xZCD")
class StringTestCase(unittest.TestCase): class StringTestCase(unittest.TestCase):
def XX_test_basic_strings(self): def XX_test_basic_strings(self):
@ -80,24 +80,24 @@ def XX_test_basic_strings(self):
# Cannot call len on a c_string any longer # Cannot call len on a c_string any longer
self.assertRaises(TypeError, len, cs) self.assertRaises(TypeError, len, cs)
self.failUnlessEqual(sizeof(cs), 7) self.assertEqual(sizeof(cs), 7)
# 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.failUnlessEqual(cs.value, "abcdef") self.assertEqual(cs.value, "abcdef")
self.failUnlessEqual(c_string("abc\000def").value, "abc") self.assertEqual(c_string("abc\000def").value, "abc")
# The raw property is the total buffer contents: # The raw property is the total buffer contents:
self.failUnlessEqual(cs.raw, "abcdef\000") self.assertEqual(cs.raw, "abcdef\000")
self.failUnlessEqual(c_string("abc\000def").raw, "abc\000def\000") self.assertEqual(c_string("abc\000def").raw, "abc\000def\000")
# We can change the value: # We can change the value:
cs.value = "ab" cs.value = "ab"
self.failUnlessEqual(cs.value, "ab") self.assertEqual(cs.value, "ab")
self.failUnlessEqual(cs.raw, "ab\000\000\000\000\000") self.assertEqual(cs.raw, "ab\000\000\000\000\000")
cs.raw = "XY" cs.raw = "XY"
self.failUnlessEqual(cs.value, "XY") self.assertEqual(cs.value, "XY")
self.failUnlessEqual(cs.raw, "XY\000\000\000\000\000") self.assertEqual(cs.raw, "XY\000\000\000\000\000")
self.assertRaises(TypeError, c_string, "123") self.assertRaises(TypeError, c_string, "123")
@ -108,24 +108,24 @@ def XX_test_sized_strings(self):
# 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.failUnless(len(c_string(32).raw) == 32) self.assertTrue(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.failUnless(c_string(2).value == "") ## self.assertTrue(c_string(2).value == "")
## self.failUnless(c_string(2).raw == "\000\000") ## self.assertTrue(c_string(2).raw == "\000\000")
self.failUnless(c_string(2).raw[-1] == "\000") self.assertTrue(c_string(2).raw[-1] == "\000")
self.failUnless(len(c_string(2).raw) == 2) self.assertTrue(len(c_string(2).raw) == 2)
def XX_test_initialized_strings(self): def XX_test_initialized_strings(self):
self.failUnless(c_string("ab", 4).raw[:2] == "ab") self.assertTrue(c_string("ab", 4).raw[:2] == "ab")
self.failUnless(c_string("ab", 4).raw[:2:] == "ab") self.assertTrue(c_string("ab", 4).raw[:2:] == "ab")
self.failUnless(c_string("ab", 4).raw[:2:-1] == "ba") self.assertTrue(c_string("ab", 4).raw[:2:-1] == "ba")
self.failUnless(c_string("ab", 4).raw[:2:2] == "a") self.assertTrue(c_string("ab", 4).raw[:2:2] == "a")
self.failUnless(c_string("ab", 4).raw[-1] == "\000") self.assertTrue(c_string("ab", 4).raw[-1] == "\000")
self.failUnless(c_string("ab", 2).raw == "a\000") self.assertTrue(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")
@ -156,22 +156,22 @@ def X_test_basic_wstrings(self):
# 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.failUnless(sizeof(cs) == 14) self.assertTrue(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.failUnless(cs.value == "abcdef") self.assertTrue(cs.value == "abcdef")
self.failUnless(c_wstring("abc\000def").value == "abc") self.assertTrue(c_wstring("abc\000def").value == "abc")
self.failUnless(c_wstring("abc\000def").value == "abc") self.assertTrue(c_wstring("abc\000def").value == "abc")
# The raw property is the total buffer contents: # The raw property is the total buffer contents:
self.failUnless(cs.raw == "abcdef\000") self.assertTrue(cs.raw == "abcdef\000")
self.failUnless(c_wstring("abc\000def").raw == "abc\000def\000") self.assertTrue(c_wstring("abc\000def").raw == "abc\000def\000")
# We can change the value: # We can change the value:
cs.value = "ab" cs.value = "ab"
self.failUnless(cs.value == "ab") self.assertTrue(cs.value == "ab")
self.failUnless(cs.raw == "ab\000\000\000\000\000") self.assertTrue(cs.raw == "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)

2
Lib/ctypes/test/test_struct_fields.py
View file

@ -15,7 +15,7 @@ class StructFieldsTestCase(unittest.TestCase):
def test_1_A(self): def test_1_A(self):
class X(Structure): class X(Structure):
pass pass
self.failUnlessEqual(sizeof(X), 0) # not finalized self.assertEqual(sizeof(X), 0) # not finalized
X._fields_ = [] # finalized X._fields_ = [] # finalized
self.assertRaises(AttributeError, setattr, X, "_fields_", []) self.assertRaises(AttributeError, setattr, X, "_fields_", [])

164
Lib/ctypes/test/test_structures.py
View file

@ -13,33 +13,33 @@ class Y(X):
class Z(X): class Z(X):
pass pass
self.failUnlessEqual(sizeof(X), sizeof(c_int)) self.assertEqual(sizeof(X), sizeof(c_int))
self.failUnlessEqual(sizeof(Y), sizeof(c_int)*2) self.assertEqual(sizeof(Y), sizeof(c_int)*2)
self.failUnlessEqual(sizeof(Z), sizeof(c_int)) self.assertEqual(sizeof(Z), sizeof(c_int))
self.failUnlessEqual(X._fields_, [("a", c_int)]) self.assertEqual(X._fields_, [("a", c_int)])
self.failUnlessEqual(Y._fields_, [("b", c_int)]) self.assertEqual(Y._fields_, [("b", c_int)])
self.failUnlessEqual(Z._fields_, [("a", c_int)]) self.assertEqual(Z._fields_, [("a", c_int)])
def test_subclass_delayed(self): def test_subclass_delayed(self):
class X(Structure): class X(Structure):
pass pass
self.failUnlessEqual(sizeof(X), 0) self.assertEqual(sizeof(X), 0)
X._fields_ = [("a", c_int)] X._fields_ = [("a", c_int)]
class Y(X): class Y(X):
pass pass
self.failUnlessEqual(sizeof(Y), sizeof(X)) self.assertEqual(sizeof(Y), sizeof(X))
Y._fields_ = [("b", c_int)] Y._fields_ = [("b", c_int)]
class Z(X): class Z(X):
pass pass
self.failUnlessEqual(sizeof(X), sizeof(c_int)) self.assertEqual(sizeof(X), sizeof(c_int))
self.failUnlessEqual(sizeof(Y), sizeof(c_int)*2) self.assertEqual(sizeof(Y), sizeof(c_int)*2)
self.failUnlessEqual(sizeof(Z), sizeof(c_int)) self.assertEqual(sizeof(Z), sizeof(c_int))
self.failUnlessEqual(X._fields_, [("a", c_int)]) self.assertEqual(X._fields_, [("a", c_int)])
self.failUnlessEqual(Y._fields_, [("b", c_int)]) self.assertEqual(Y._fields_, [("b", c_int)])
self.failUnlessEqual(Z._fields_, [("a", c_int)]) self.assertEqual(Z._fields_, [("a", c_int)])
class StructureTestCase(unittest.TestCase): class StructureTestCase(unittest.TestCase):
formats = {"c": c_char, formats = {"c": c_char,
@ -62,7 +62,7 @@ def test_simple_structs(self):
class X(Structure): class X(Structure):
_fields_ = [("x", c_char), _fields_ = [("x", c_char),
("y", tp)] ("y", tp)]
self.failUnlessEqual((sizeof(X), code), self.assertEqual((sizeof(X), code),
(calcsize("c%c0%c" % (code, code)), code)) (calcsize("c%c0%c" % (code, code)), code))
def test_unions(self): def test_unions(self):
@ -70,39 +70,39 @@ def test_unions(self):
class X(Union): class X(Union):
_fields_ = [("x", c_char), _fields_ = [("x", c_char),
("y", tp)] ("y", tp)]
self.failUnlessEqual((sizeof(X), code), self.assertEqual((sizeof(X), code),
(calcsize("%c" % (code)), code)) (calcsize("%c" % (code)), code))
def test_struct_alignment(self): def test_struct_alignment(self):
class X(Structure): class X(Structure):
_fields_ = [("x", c_char * 3)] _fields_ = [("x", c_char * 3)]
self.failUnlessEqual(alignment(X), calcsize("s")) self.assertEqual(alignment(X), calcsize("s"))
self.failUnlessEqual(sizeof(X), calcsize("3s")) self.assertEqual(sizeof(X), calcsize("3s"))
class Y(Structure): class Y(Structure):
_fields_ = [("x", c_char * 3), _fields_ = [("x", c_char * 3),
("y", c_int)] ("y", c_int)]
self.failUnlessEqual(alignment(Y), calcsize("i")) self.assertEqual(alignment(Y), calcsize("i"))
self.failUnlessEqual(sizeof(Y), calcsize("3si")) self.assertEqual(sizeof(Y), calcsize("3si"))
class SI(Structure): class SI(Structure):
_fields_ = [("a", X), _fields_ = [("a", X),
("b", Y)] ("b", Y)]
self.failUnlessEqual(alignment(SI), max(alignment(Y), alignment(X))) self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
self.failUnlessEqual(sizeof(SI), calcsize("3s0i 3si 0i")) self.assertEqual(sizeof(SI), calcsize("3s0i 3si 0i"))
class IS(Structure): class IS(Structure):
_fields_ = [("b", Y), _fields_ = [("b", Y),
("a", X)] ("a", X)]
self.failUnlessEqual(alignment(SI), max(alignment(X), alignment(Y))) self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
self.failUnlessEqual(sizeof(IS), calcsize("3si 3s 0i")) self.assertEqual(sizeof(IS), calcsize("3si 3s 0i"))
class XX(Structure): class XX(Structure):
_fields_ = [("a", X), _fields_ = [("a", X),
("b", X)] ("b", X)]
self.failUnlessEqual(alignment(XX), alignment(X)) self.assertEqual(alignment(XX), alignment(X))
self.failUnlessEqual(sizeof(XX), calcsize("3s 3s 0s")) self.assertEqual(sizeof(XX), calcsize("3s 3s 0s"))
def test_emtpy(self): def test_emtpy(self):
# I had problems with these # I had problems with these
@ -115,15 +115,15 @@ class Y(Union):
_fields_ = [] _fields_ = []
# Is this really the correct alignment, or should it be 0? # Is this really the correct alignment, or should it be 0?
self.failUnless(alignment(X) == alignment(Y) == 1) self.assertTrue(alignment(X) == alignment(Y) == 1)
self.failUnless(sizeof(X) == sizeof(Y) == 0) self.assertTrue(sizeof(X) == sizeof(Y) == 0)
class XX(Structure): class XX(Structure):
_fields_ = [("a", X), _fields_ = [("a", X),
("b", X)] ("b", X)]
self.failUnlessEqual(alignment(XX), 1) self.assertEqual(alignment(XX), 1)
self.failUnlessEqual(sizeof(XX), 0) self.assertEqual(sizeof(XX), 0)
def test_fields(self): def test_fields(self):
# test the offset and size attributes of Structure/Unoin fields. # test the offset and size attributes of Structure/Unoin fields.
@ -131,11 +131,11 @@ class X(Structure):
_fields_ = [("x", c_int), _fields_ = [("x", c_int),
("y", c_char)] ("y", c_char)]
self.failUnlessEqual(X.x.offset, 0) self.assertEqual(X.x.offset, 0)
self.failUnlessEqual(X.x.size, sizeof(c_int)) self.assertEqual(X.x.size, sizeof(c_int))
self.failUnlessEqual(X.y.offset, sizeof(c_int)) self.assertEqual(X.y.offset, sizeof(c_int))
self.failUnlessEqual(X.y.size, sizeof(c_char)) self.assertEqual(X.y.size, sizeof(c_char))
# readonly # readonly
self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92) self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
@ -145,11 +145,11 @@ class X(Union):
_fields_ = [("x", c_int), _fields_ = [("x", c_int),
("y", c_char)] ("y", c_char)]
self.failUnlessEqual(X.x.offset, 0) self.assertEqual(X.x.offset, 0)
self.failUnlessEqual(X.x.size, sizeof(c_int)) self.assertEqual(X.x.size, sizeof(c_int))
self.failUnlessEqual(X.y.offset, 0) self.assertEqual(X.y.offset, 0)
self.failUnlessEqual(X.y.size, sizeof(c_char)) self.assertEqual(X.y.size, sizeof(c_char))
# readonly # readonly
self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92) self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
@ -164,22 +164,22 @@ class X(Structure):
("b", c_longlong)] ("b", c_longlong)]
_pack_ = 1 _pack_ = 1
self.failUnlessEqual(sizeof(X), 9) self.assertEqual(sizeof(X), 9)
self.failUnlessEqual(X.b.offset, 1) self.assertEqual(X.b.offset, 1)
class X(Structure): class X(Structure):
_fields_ = [("a", c_byte), _fields_ = [("a", c_byte),
("b", c_longlong)] ("b", c_longlong)]
_pack_ = 2 _pack_ = 2
self.failUnlessEqual(sizeof(X), 10) self.assertEqual(sizeof(X), 10)
self.failUnlessEqual(X.b.offset, 2) self.assertEqual(X.b.offset, 2)
class X(Structure): class X(Structure):
_fields_ = [("a", c_byte), _fields_ = [("a", c_byte),
("b", c_longlong)] ("b", c_longlong)]
_pack_ = 4 _pack_ = 4
self.failUnlessEqual(sizeof(X), 12) self.assertEqual(sizeof(X), 12)
self.failUnlessEqual(X.b.offset, 4) self.assertEqual(X.b.offset, 4)
import struct import struct
longlong_size = struct.calcsize("q") longlong_size = struct.calcsize("q")
@ -190,8 +190,8 @@ class X(Structure):
("b", c_longlong)] ("b", c_longlong)]
_pack_ = 8 _pack_ = 8
self.failUnlessEqual(sizeof(X), longlong_align + longlong_size) self.assertEqual(sizeof(X), longlong_align + longlong_size)
self.failUnlessEqual(X.b.offset, min(8, longlong_align)) self.assertEqual(X.b.offset, min(8, longlong_align))
d = {"_fields_": [("a", "b"), d = {"_fields_": [("a", "b"),
@ -209,9 +209,9 @@ class Person(Structure):
self.assertRaises(TypeError, Person, "Name", "HI") self.assertRaises(TypeError, Person, "Name", "HI")
# short enough # short enough
self.failUnlessEqual(Person("12345", 5).name, "12345") self.assertEqual(Person("12345", 5).name, "12345")
# exact fit # exact fit
self.failUnlessEqual(Person("123456", 5).name, "123456") self.assertEqual(Person("123456", 5).name, "123456")
# too long # too long
self.assertRaises(ValueError, Person, "1234567", 5) self.assertRaises(ValueError, Person, "1234567", 5)
@ -229,10 +229,10 @@ def test_keyword_initializers(self):
class POINT(Structure): class POINT(Structure):
_fields_ = [("x", c_int), ("y", c_int)] _fields_ = [("x", c_int), ("y", c_int)]
pt = POINT(1, 2) pt = POINT(1, 2)
self.failUnlessEqual((pt.x, pt.y), (1, 2)) self.assertEqual((pt.x, pt.y), (1, 2))
pt = POINT(y=2, x=1) pt = POINT(y=2, x=1)
self.failUnlessEqual((pt.x, pt.y), (1, 2)) self.assertEqual((pt.x, pt.y), (1, 2))
def test_invalid_field_types(self): def test_invalid_field_types(self):
class POINT(Structure): class POINT(Structure):
@ -244,14 +244,14 @@ class SomeInts(Structure):
_fields_ = [("a", c_int * 4)] _fields_ = [("a", c_int * 4)]
# can use tuple to initialize array (but not list!) # can use tuple to initialize array (but not list!)
self.failUnlessEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0]) self.assertEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
self.failUnlessEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0]) self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
self.failUnlessEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1]) self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
self.failUnlessEqual(SomeInts((1, 2)).a[::2], [1, 0]) self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
self.failUnlessEqual(SomeInts((1, 2)).a[1:5:6], [2]) self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
self.failUnlessEqual(SomeInts((1, 2)).a[6:4:-1], []) self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
self.failUnlessEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4]) self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
self.failUnlessEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4]) self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
# too long # too long
# XXX Should raise ValueError?, not RuntimeError # XXX Should raise ValueError?, not RuntimeError
self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5)) self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
@ -269,10 +269,10 @@ class Person(Structure):
p = Person("Someone", ("1234", "5678"), 5) p = Person("Someone", ("1234", "5678"), 5)
self.failUnlessEqual(p.name, "Someone") self.assertEqual(p.name, "Someone")
self.failUnlessEqual(p.phone.areacode, "1234") self.assertEqual(p.phone.areacode, "1234")
self.failUnlessEqual(p.phone.number, "5678") self.assertEqual(p.phone.number, "5678")
self.failUnlessEqual(p.age, 5) self.assertEqual(p.age, 5)
def test_structures_with_wchar(self): def test_structures_with_wchar(self):
try: try:
@ -285,12 +285,12 @@ class PersonW(Structure):
("age", c_int)] ("age", c_int)]
p = PersonW("Someone") p = PersonW("Someone")
self.failUnlessEqual(p.name, "Someone") self.assertEqual(p.name, "Someone")
self.failUnlessEqual(PersonW("1234567890").name, "1234567890") self.assertEqual(PersonW("1234567890").name, "1234567890")
self.failUnlessEqual(PersonW("12345678901").name, "12345678901") self.assertEqual(PersonW("12345678901").name, "12345678901")
# exact fit # exact fit
self.failUnlessEqual(PersonW("123456789012").name, "123456789012") self.assertEqual(PersonW("123456789012").name, "123456789012")
#too long #too long
self.assertRaises(ValueError, PersonW, "1234567890123") self.assertRaises(ValueError, PersonW, "1234567890123")
@ -305,18 +305,18 @@ class Person(Structure):
("age", c_int)] ("age", c_int)]
cls, msg = self.get_except(Person, "Someone", (1, 2)) cls, msg = self.get_except(Person, "Someone", (1, 2))
self.failUnlessEqual(cls, RuntimeError) self.assertEqual(cls, RuntimeError)
self.failUnlessEqual(msg, self.assertEqual(msg,
"(Phone) <class 'TypeError'>: " "(Phone) <class 'TypeError'>: "
"expected string, int found") "expected string, int found")
cls, msg = self.get_except(Person, "Someone", ("a", "b", "c")) cls, msg = self.get_except(Person, "Someone", ("a", "b", "c"))
self.failUnlessEqual(cls, RuntimeError) self.assertEqual(cls, RuntimeError)
if issubclass(Exception, object): if issubclass(Exception, object):
self.failUnlessEqual(msg, self.assertEqual(msg,
"(Phone) <class 'TypeError'>: too many initializers") "(Phone) <class 'TypeError'>: too many initializers")
else: else:
self.failUnlessEqual(msg, "(Phone) TypeError: too many initializers") self.assertEqual(msg, "(Phone) TypeError: too many initializers")
def get_except(self, func, *args): def get_except(self, func, *args):
@ -331,7 +331,7 @@ def get_except(self, func, *args):
## # same as 'class X(Structure): pass' ## # same as 'class X(Structure): pass'
## # fails, since we need either a _fields_ or a _abstract_ attribute ## # fails, since we need either a _fields_ or a _abstract_ attribute
## cls, msg = self.get_except(meta, "X", (Structure,), {}) ## cls, msg = self.get_except(meta, "X", (Structure,), {})
## self.failUnlessEqual((cls, msg), ## self.assertEqual((cls, msg),
## (AttributeError, "class must define a '_fields_' attribute")) ## (AttributeError, "class must define a '_fields_' attribute"))
def test_abstract_class(self): def test_abstract_class(self):
@ -339,15 +339,15 @@ class X(Structure):
_abstract_ = "something" _abstract_ = "something"
# try 'X()' # try 'X()'
cls, msg = self.get_except(eval, "X()", locals()) cls, msg = self.get_except(eval, "X()", locals())
self.failUnlessEqual((cls, msg), (TypeError, "abstract class")) self.assertEqual((cls, msg), (TypeError, "abstract class"))
def test_methods(self): def test_methods(self):
## class X(Structure): ## class X(Structure):
## _fields_ = [] ## _fields_ = []
self.failUnless("in_dll" in dir(type(Structure))) self.assertTrue("in_dll" in dir(type(Structure)))
self.failUnless("from_address" in dir(type(Structure))) self.assertTrue("from_address" in dir(type(Structure)))
self.failUnless("in_dll" in dir(type(Structure))) self.assertTrue("in_dll" in dir(type(Structure)))
class PointerMemberTestCase(unittest.TestCase): class PointerMemberTestCase(unittest.TestCase):
@ -360,7 +360,7 @@ class S(Structure):
# We can assign arrays of the correct type # We can assign arrays of the correct type
s.array = (c_int * 3)(1, 2, 3) s.array = (c_int * 3)(1, 2, 3)
items = [s.array[i] for i in range(3)] items = [s.array[i] for i in range(3)]
self.failUnlessEqual(items, [1, 2, 3]) self.assertEqual(items, [1, 2, 3])
# The following are bugs, but are included here because the unittests # The following are bugs, but are included here because the unittests
# also describe the current behaviour. # also describe the current behaviour.
@ -371,14 +371,14 @@ class S(Structure):
s.array[0] = 42 s.array[0] = 42
items = [s.array[i] for i in range(3)] items = [s.array[i] for i in range(3)]
self.failUnlessEqual(items, [42, 2, 3]) self.assertEqual(items, [42, 2, 3])
s.array[0] = 1 s.array[0] = 1
## s.array[1] = 42 ## s.array[1] = 42
items = [s.array[i] for i in range(3)] items = [s.array[i] for i in range(3)]
self.failUnlessEqual(items, [1, 2, 3]) self.assertEqual(items, [1, 2, 3])
def test_none_to_pointer_fields(self): def test_none_to_pointer_fields(self):
class S(Structure): class S(Structure):
@ -388,7 +388,7 @@ class S(Structure):
s = S() s = S()
s.x = 12345678 s.x = 12345678
s.p = None s.p = None
self.failUnlessEqual(s.x, 12345678) self.assertEqual(s.x, 12345678)
class TestRecursiveStructure(unittest.TestCase): class TestRecursiveStructure(unittest.TestCase):
def test_contains_itself(self): def test_contains_itself(self):
@ -398,7 +398,7 @@ class Recursive(Structure):
try: try:
Recursive._fields_ = [("next", Recursive)] Recursive._fields_ = [("next", Recursive)]
except AttributeError as details: except AttributeError as details:
self.failUnless("Structure or union cannot contain itself" in self.assertTrue("Structure or union cannot contain itself" in
str(details)) str(details))
else: else:
self.fail("Structure or union cannot contain itself") self.fail("Structure or union cannot contain itself")
@ -415,7 +415,7 @@ class Second(Structure):
try: try:
Second._fields_ = [("first", First)] Second._fields_ = [("first", First)]
except AttributeError as details: except AttributeError as details:
self.failUnless("_fields_ is final" in self.assertTrue("_fields_ is final" in
str(details)) str(details))
else: else:
self.fail("AttributeError not raised") self.fail("AttributeError not raised")

8
Lib/ctypes/test/test_unaligned_structures.py
View file

@ -28,18 +28,18 @@ class TestStructures(unittest.TestCase):
def test_native(self): def test_native(self):
for typ in structures: for typ in structures:
## print typ.value ## print typ.value
self.failUnlessEqual(typ.value.offset, 1) self.assertEqual(typ.value.offset, 1)
o = typ() o = typ()
o.value = 4 o.value = 4
self.failUnlessEqual(o.value, 4) self.assertEqual(o.value, 4)
def test_swapped(self): def test_swapped(self):
for typ in byteswapped_structures: for typ in byteswapped_structures:
## print >> sys.stderr, typ.value ## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1) self.assertEqual(typ.value.offset, 1)
o = typ() o = typ()
o.value = 4 o.value = 4
self.failUnlessEqual(o.value, 4) self.assertEqual(o.value, 4)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

88
Lib/ctypes/test/test_unicode.py
View file

@ -22,55 +22,55 @@ def tearDown(self):
def test_ascii_strict(self): def test_ascii_strict(self):
ctypes.set_conversion_mode("ascii", "strict") ctypes.set_conversion_mode("ascii", "strict")
# no conversions take place with unicode arguments # no conversions take place with unicode arguments
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("ab\u2070"), 3) self.assertEqual(wcslen("ab\u2070"), 3)
# string args are converted # string args are converted
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessRaises(ctypes.ArgumentError, wcslen, b"ab\xe4") self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
def test_ascii_replace(self): def test_ascii_replace(self):
ctypes.set_conversion_mode("ascii", "replace") ctypes.set_conversion_mode("ascii", "replace")
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("ab\u2070"), 3) self.assertEqual(wcslen("ab\u2070"), 3)
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("ab\xe4"), 3) self.assertEqual(wcslen("ab\xe4"), 3)
def test_ascii_ignore(self): def test_ascii_ignore(self):
ctypes.set_conversion_mode("ascii", "ignore") ctypes.set_conversion_mode("ascii", "ignore")
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("ab\u2070"), 3) self.assertEqual(wcslen("ab\u2070"), 3)
# ignore error mode skips non-ascii characters # ignore error mode skips non-ascii characters
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen(b"\xe4\xf6\xfc\xdf"), 0) self.assertEqual(wcslen(b"\xe4\xf6\xfc\xdf"), 0)
def test_latin1_strict(self): def test_latin1_strict(self):
ctypes.set_conversion_mode("latin-1", "strict") ctypes.set_conversion_mode("latin-1", "strict")
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("ab\u2070"), 3) self.assertEqual(wcslen("ab\u2070"), 3)
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("\xe4\xf6\xfc\xdf"), 4) self.assertEqual(wcslen("\xe4\xf6\xfc\xdf"), 4)
def test_buffers(self): def test_buffers(self):
ctypes.set_conversion_mode("ascii", "strict") ctypes.set_conversion_mode("ascii", "strict")
buf = ctypes.create_unicode_buffer("abc") buf = ctypes.create_unicode_buffer("abc")
self.failUnlessEqual(len(buf), 3+1) self.assertEqual(len(buf), 3+1)
ctypes.set_conversion_mode("ascii", "replace") ctypes.set_conversion_mode("ascii", "replace")
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc") buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
self.failUnlessEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0") self.assertEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0")
self.failUnlessEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0") self.assertEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0")
self.failUnlessEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba") self.assertEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba")
self.failUnlessEqual(buf[::2], "a\uFFFD\uFFFD") self.assertEqual(buf[::2], "a\uFFFD\uFFFD")
self.failUnlessEqual(buf[6:5:-1], "") self.assertEqual(buf[6:5:-1], "")
ctypes.set_conversion_mode("ascii", "ignore") ctypes.set_conversion_mode("ascii", "ignore")
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc") buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
# is that correct? not sure. But with 'ignore', you get what you pay for.. # is that correct? not sure. But with 'ignore', you get what you pay for..
self.failUnlessEqual(buf[:], "ab\0\0\0\0") self.assertEqual(buf[:], "ab\0\0\0\0")
self.failUnlessEqual(buf[::], "ab\0\0\0\0") self.assertEqual(buf[::], "ab\0\0\0\0")
self.failUnlessEqual(buf[::-1], "\0\0\0\0ba") self.assertEqual(buf[::-1], "\0\0\0\0ba")
self.failUnlessEqual(buf[::2], "a\0\0") self.assertEqual(buf[::2], "a\0\0")
self.failUnlessEqual(buf[6:5:-1], "") self.assertEqual(buf[6:5:-1], "")
import _ctypes_test import _ctypes_test
func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
@ -88,41 +88,41 @@ def tearDown(self):
def test_ascii_replace(self): def test_ascii_replace(self):
ctypes.set_conversion_mode("ascii", "strict") ctypes.set_conversion_mode("ascii", "strict")
self.failUnlessEqual(func("abc"), "abc") self.assertEqual(func("abc"), "abc")
self.failUnlessEqual(func("abc"), "abc") self.assertEqual(func("abc"), "abc")
self.assertRaises(ctypes.ArgumentError, func, "ab\xe4") self.assertRaises(ctypes.ArgumentError, func, "ab\xe4")
def test_ascii_ignore(self): def test_ascii_ignore(self):
ctypes.set_conversion_mode("ascii", "ignore") ctypes.set_conversion_mode("ascii", "ignore")
self.failUnlessEqual(func("abc"), "abc") self.assertEqual(func("abc"), "abc")
self.failUnlessEqual(func("abc"), "abc") self.assertEqual(func("abc"), "abc")
self.failUnlessEqual(func("\xe4\xf6\xfc\xdf"), "") self.assertEqual(func("\xe4\xf6\xfc\xdf"), "")
def test_ascii_replace(self): def test_ascii_replace(self):
ctypes.set_conversion_mode("ascii", "replace") ctypes.set_conversion_mode("ascii", "replace")
self.failUnlessEqual(func("abc"), "abc") self.assertEqual(func("abc"), "abc")
self.failUnlessEqual(func("abc"), "abc") self.assertEqual(func("abc"), "abc")
self.failUnlessEqual(func("\xe4\xf6\xfc\xdf"), "????") self.assertEqual(func("\xe4\xf6\xfc\xdf"), "????")
def test_buffers(self): def test_buffers(self):
ctypes.set_conversion_mode("ascii", "strict") ctypes.set_conversion_mode("ascii", "strict")
buf = ctypes.create_string_buffer("abc") buf = ctypes.create_string_buffer("abc")
self.failUnlessEqual(len(buf), 3+1) self.assertEqual(len(buf), 3+1)
ctypes.set_conversion_mode("ascii", "replace") ctypes.set_conversion_mode("ascii", "replace")
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc") buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
self.failUnlessEqual(buf[:], b"ab???\0") self.assertEqual(buf[:], b"ab???\0")
self.failUnlessEqual(buf[::], b"ab???\0") self.assertEqual(buf[::], b"ab???\0")
self.failUnlessEqual(buf[::-1], b"\0???ba") self.assertEqual(buf[::-1], b"\0???ba")
self.failUnlessEqual(buf[::2], b"a??") self.assertEqual(buf[::2], b"a??")
self.failUnlessEqual(buf[6:5:-1], b"") self.assertEqual(buf[6:5:-1], b"")
ctypes.set_conversion_mode("ascii", "ignore") ctypes.set_conversion_mode("ascii", "ignore")
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc") buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
# is that correct? not sure. But with 'ignore', you get what you pay for.. # is that correct? not sure. But with 'ignore', you get what you pay for..
self.failUnlessEqual(buf[:], b"ab\0\0\0\0") self.assertEqual(buf[:], b"ab\0\0\0\0")
self.failUnlessEqual(buf[::], b"ab\0\0\0\0") self.assertEqual(buf[::], b"ab\0\0\0\0")
self.failUnlessEqual(buf[::-1], b"\0\0\0\0ba") self.assertEqual(buf[::-1], b"\0\0\0\0ba")
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

14
Lib/ctypes/test/test_values.py
View file

@ -15,13 +15,13 @@ def test_an_integer(self):
ctdll = CDLL(_ctypes_test.__file__) ctdll = CDLL(_ctypes_test.__file__)
an_integer = c_int.in_dll(ctdll, "an_integer") an_integer = c_int.in_dll(ctdll, "an_integer")
x = an_integer.value x = an_integer.value
self.failUnlessEqual(x, ctdll.get_an_integer()) self.assertEqual(x, ctdll.get_an_integer())
an_integer.value *= 2 an_integer.value *= 2
self.failUnlessEqual(x*2, ctdll.get_an_integer()) self.assertEqual(x*2, ctdll.get_an_integer())
# To avoid test failures when this test is repeated several # To avoid test failures when this test is repeated several
# times the original value must be restored # times the original value must be restored
an_integer.value = x an_integer.value = x
self.failUnlessEqual(x, ctdll.get_an_integer()) self.assertEqual(x, ctdll.get_an_integer())
def test_undefined(self): def test_undefined(self):
ctdll = CDLL(_ctypes_test.__file__) ctdll = CDLL(_ctypes_test.__file__)
@ -40,11 +40,11 @@ def test_optimizeflag(self):
# docstrings are also removed in the latter case. # docstrings are also removed in the latter case.
opt = c_int.in_dll(pydll, "Py_OptimizeFlag").value opt = c_int.in_dll(pydll, "Py_OptimizeFlag").value
if __debug__: if __debug__:
self.failUnlessEqual(opt, 0) self.assertEqual(opt, 0)
elif ValuesTestCase.__doc__ is not None: elif ValuesTestCase.__doc__ is not None:
self.failUnlessEqual(opt, 1) self.assertEqual(opt, 1)
else: else:
self.failUnlessEqual(opt, 2) self.assertEqual(opt, 2)
def test_frozentable(self): def test_frozentable(self):
# Python exports a PyImport_FrozenModules symbol. This is a # Python exports a PyImport_FrozenModules symbol. This is a
@ -76,7 +76,7 @@ class struct_frozen(Structure):
expected = [("__hello__", 104), ("__phello__", -104), ("__phello__.spam", 104)] expected = [("__hello__", 104), ("__phello__", -104), ("__phello__.spam", 104)]
else: else:
expected = [("__hello__", 100), ("__phello__", -100), ("__phello__.spam", 100)] expected = [("__hello__", 100), ("__phello__", -100), ("__phello__.spam", 100)]
self.failUnlessEqual(items, expected) self.assertEqual(items, expected)
from ctypes import _pointer_type_cache from ctypes import _pointer_type_cache
del _pointer_type_cache[struct_frozen] del _pointer_type_cache[struct_frozen]

32
Lib/ctypes/test/test_varsize_struct.py
View file

@ -7,44 +7,44 @@ class X(Structure):
_fields_ = [("item", c_int), _fields_ = [("item", c_int),
("array", c_int * 1)] ("array", c_int * 1)]
self.failUnlessEqual(sizeof(X), sizeof(c_int) * 2) self.assertEqual(sizeof(X), sizeof(c_int) * 2)
x = X() x = X()
x.item = 42 x.item = 42
x.array[0] = 100 x.array[0] = 100
self.failUnlessEqual(sizeof(x), sizeof(c_int) * 2) self.assertEqual(sizeof(x), sizeof(c_int) * 2)
# make room for one additional item # make room for one additional item
new_size = sizeof(X) + sizeof(c_int) * 1 new_size = sizeof(X) + sizeof(c_int) * 1
resize(x, new_size) resize(x, new_size)
self.failUnlessEqual(sizeof(x), new_size) self.assertEqual(sizeof(x), new_size)
self.failUnlessEqual((x.item, x.array[0]), (42, 100)) self.assertEqual((x.item, x.array[0]), (42, 100))
# make room for 10 additional items # make room for 10 additional items
new_size = sizeof(X) + sizeof(c_int) * 9 new_size = sizeof(X) + sizeof(c_int) * 9
resize(x, new_size) resize(x, new_size)
self.failUnlessEqual(sizeof(x), new_size) self.assertEqual(sizeof(x), new_size)
self.failUnlessEqual((x.item, x.array[0]), (42, 100)) self.assertEqual((x.item, x.array[0]), (42, 100))
# make room for one additional item # make room for one additional item
new_size = sizeof(X) + sizeof(c_int) * 1 new_size = sizeof(X) + sizeof(c_int) * 1
resize(x, new_size) resize(x, new_size)
self.failUnlessEqual(sizeof(x), new_size) self.assertEqual(sizeof(x), new_size)
self.failUnlessEqual((x.item, x.array[0]), (42, 100)) self.assertEqual((x.item, x.array[0]), (42, 100))
def test_array_invalid_length(self): def test_array_invalid_length(self):
# cannot create arrays with non-positive size # cannot create arrays with non-positive size
self.failUnlessRaises(ValueError, lambda: c_int * -1) self.assertRaises(ValueError, lambda: c_int * -1)
self.failUnlessRaises(ValueError, lambda: c_int * -3) self.assertRaises(ValueError, lambda: c_int * -3)
def test_zerosized_array(self): def test_zerosized_array(self):
array = (c_int * 0)() array = (c_int * 0)()
# accessing elements of zero-sized arrays raise IndexError # accessing elements of zero-sized arrays raise IndexError
self.failUnlessRaises(IndexError, array.__setitem__, 0, None) self.assertRaises(IndexError, array.__setitem__, 0, None)
self.failUnlessRaises(IndexError, array.__getitem__, 0) self.assertRaises(IndexError, array.__getitem__, 0)
self.failUnlessRaises(IndexError, array.__setitem__, 1, None) self.assertRaises(IndexError, array.__setitem__, 1, None)
self.failUnlessRaises(IndexError, array.__getitem__, 1) self.assertRaises(IndexError, array.__getitem__, 1)
self.failUnlessRaises(IndexError, array.__setitem__, -1, None) self.assertRaises(IndexError, array.__setitem__, -1, None)
self.failUnlessRaises(IndexError, array.__getitem__, -1) self.assertRaises(IndexError, array.__getitem__, -1)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

10
Lib/ctypes/test/test_win32.py
View file

@ -18,7 +18,7 @@ def test_callconv_1(self):
self.assertRaises(ValueError, IsWindow) self.assertRaises(ValueError, IsWindow)
# This one should succeeed... # This one should succeeed...
self.failUnlessEqual(0, IsWindow(0)) self.assertEqual(0, IsWindow(0))
# ValueError: Procedure probably called with too many arguments (8 bytes in excess) # ValueError: Procedure probably called with too many arguments (8 bytes in excess)
self.assertRaises(ValueError, IsWindow, 0, 0, 0) self.assertRaises(ValueError, IsWindow, 0, 0, 0)
@ -49,13 +49,13 @@ def test_noargs(self):
class TestWintypes(unittest.TestCase): class TestWintypes(unittest.TestCase):
def test_HWND(self): def test_HWND(self):
from ctypes import wintypes from ctypes import wintypes
self.failUnlessEqual(sizeof(wintypes.HWND), sizeof(c_void_p)) self.assertEqual(sizeof(wintypes.HWND), sizeof(c_void_p))
def test_PARAM(self): def test_PARAM(self):
from ctypes import wintypes from ctypes import wintypes
self.failUnlessEqual(sizeof(wintypes.WPARAM), self.assertEqual(sizeof(wintypes.WPARAM),
sizeof(c_void_p)) sizeof(c_void_p))
self.failUnlessEqual(sizeof(wintypes.LPARAM), self.assertEqual(sizeof(wintypes.LPARAM),
sizeof(c_void_p)) sizeof(c_void_p))
def test_COMError(self): def test_COMError(self):
@ -84,7 +84,7 @@ class RECT(Structure):
pt = POINT(10, 10) pt = POINT(10, 10)
rect = RECT(0, 0, 20, 20) rect = RECT(0, 0, 20, 20)
self.failUnlessEqual(1, dll.PointInRect(byref(rect), pt)) self.assertEqual(1, dll.PointInRect(byref(rect), pt))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

16
Lib/distutils/tests/test_archive_util.py
View file

@ -47,7 +47,7 @@ def test_make_tarball(self):
# check if the compressed tarball was created # check if the compressed tarball was created
tarball = base_name + '.tar.gz' tarball = base_name + '.tar.gz'
self.assert_(os.path.exists(tarball)) self.assertTrue(os.path.exists(tarball))
# trying an uncompressed one # trying an uncompressed one
base_name = os.path.join(tmpdir2, 'archive') base_name = os.path.join(tmpdir2, 'archive')
@ -58,7 +58,7 @@ def test_make_tarball(self):
finally: finally:
os.chdir(old_dir) os.chdir(old_dir)
tarball = base_name + '.tar' tarball = base_name + '.tar'
self.assert_(os.path.exists(tarball)) self.assertTrue(os.path.exists(tarball))
def _tarinfo(self, path): def _tarinfo(self, path):
tar = tarfile.open(path) tar = tarfile.open(path)
@ -96,7 +96,7 @@ def test_tarfile_vs_tar(self):
# check if the compressed tarball was created # check if the compressed tarball was created
tarball = base_name + '.tar.gz' tarball = base_name + '.tar.gz'
self.assert_(os.path.exists(tarball)) self.assertTrue(os.path.exists(tarball))
# now create another tarball using `tar` # now create another tarball using `tar`
tarball2 = os.path.join(tmpdir, 'archive2.tar.gz') tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
@ -110,7 +110,7 @@ def test_tarfile_vs_tar(self):
finally: finally:
os.chdir(old_dir) os.chdir(old_dir)
self.assert_(os.path.exists(tarball2)) self.assertTrue(os.path.exists(tarball2))
# let's compare both tarballs # let's compare both tarballs
self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2)) self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2))
@ -123,7 +123,7 @@ def test_tarfile_vs_tar(self):
finally: finally:
os.chdir(old_dir) os.chdir(old_dir)
tarball = base_name + '.tar' tarball = base_name + '.tar'
self.assert_(os.path.exists(tarball)) self.assertTrue(os.path.exists(tarball))
# now for a dry_run # now for a dry_run
base_name = os.path.join(tmpdir2, 'archive') base_name = os.path.join(tmpdir2, 'archive')
@ -134,7 +134,7 @@ def test_tarfile_vs_tar(self):
finally: finally:
os.chdir(old_dir) os.chdir(old_dir)
tarball = base_name + '.tar' tarball = base_name + '.tar'
self.assert_(os.path.exists(tarball)) self.assertTrue(os.path.exists(tarball))
@unittest.skipUnless(find_executable('compress'), @unittest.skipUnless(find_executable('compress'),
'The compress program is required') 'The compress program is required')
@ -151,7 +151,7 @@ def test_compress_deprecated(self):
finally: finally:
os.chdir(old_dir) os.chdir(old_dir)
tarball = base_name + '.tar.Z' tarball = base_name + '.tar.Z'
self.assert_(os.path.exists(tarball)) self.assertTrue(os.path.exists(tarball))
self.assertEquals(len(w.warnings), 1) self.assertEquals(len(w.warnings), 1)
# same test with dry_run # same test with dry_run
@ -165,7 +165,7 @@ def test_compress_deprecated(self):
dry_run=True) dry_run=True)
finally: finally:
os.chdir(old_dir) os.chdir(old_dir)
self.assert_(not os.path.exists(tarball)) self.assertTrue(not os.path.exists(tarball))
self.assertEquals(len(w.warnings), 1) self.assertEquals(len(w.warnings), 1)
@unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run') @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')

4
Lib/distutils/tests/test_bdist_rpm.py
View file

@ -74,7 +74,7 @@ def test_quiet(self):
cmd.run() cmd.run()
dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
self.assert_('foo-0.1-1.noarch.rpm' in dist_created) self.assertTrue('foo-0.1-1.noarch.rpm' in dist_created)
def test_no_optimize_flag(self): def test_no_optimize_flag(self):
@ -114,7 +114,7 @@ def test_no_optimize_flag(self):
cmd.run() cmd.run()
dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
self.assert_('foo-0.1-1.noarch.rpm' in dist_created) self.assertTrue('foo-0.1-1.noarch.rpm' in dist_created)
os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm')) os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm'))
def test_suite(): def test_suite():

2
Lib/distutils/tests/test_bdist_wininst.py
View file

@ -21,7 +21,7 @@ def test_get_exe_bytes(self):
# and make sure it finds it and returns its content # and make sure it finds it and returns its content
# no matter what platform we have # no matter what platform we have
exe_file = cmd.get_exe_bytes() exe_file = cmd.get_exe_bytes()
self.assert_(len(exe_file) > 10) self.assertTrue(len(exe_file) > 10)
def test_suite(): def test_suite():
return unittest.makeSuite(BuildWinInstTestCase) return unittest.makeSuite(BuildWinInstTestCase)

2
Lib/distutils/tests/test_build_clib.py
View file

@ -135,7 +135,7 @@ def test_run(self):
cmd.run() cmd.run()
# let's check the result # let's check the result
self.assert_('libfoo.a' in os.listdir(build_temp)) self.assertTrue('libfoo.a' in os.listdir(build_temp))
def test_suite(): def test_suite():
return unittest.makeSuite(BuildCLibTestCase) return unittest.makeSuite(BuildCLibTestCase)

30
Lib/distutils/tests/test_build_ext.py
View file

@ -74,15 +74,15 @@ def test_build_ext(self):
import xx import xx
for attr in ('error', 'foo', 'new', 'roj'): for attr in ('error', 'foo', 'new', 'roj'):
self.assert_(hasattr(xx, attr)) self.assertTrue(hasattr(xx, attr))
self.assertEquals(xx.foo(2, 5), 7) self.assertEquals(xx.foo(2, 5), 7)
self.assertEquals(xx.foo(13,15), 28) self.assertEquals(xx.foo(13,15), 28)
self.assertEquals(xx.new().demo(), None) self.assertEquals(xx.new().demo(), None)
doc = 'This is a template module just for instruction.' doc = 'This is a template module just for instruction.'
self.assertEquals(xx.__doc__, doc) self.assertEquals(xx.__doc__, doc)
self.assert_(isinstance(xx.Null(), xx.Null)) self.assertTrue(isinstance(xx.Null(), xx.Null))
self.assert_(isinstance(xx.Str(), xx.Str)) self.assertTrue(isinstance(xx.Str(), xx.Str))
def tearDown(self): def tearDown(self):
# Get everything back to normal # Get everything back to normal
@ -114,7 +114,7 @@ def test_solaris_enable_shared(self):
_config_vars['Py_ENABLE_SHARED'] = old_var _config_vars['Py_ENABLE_SHARED'] = old_var
# make sure we get some library dirs under solaris # make sure we get some library dirs under solaris
self.assert_(len(cmd.library_dirs) > 0) self.assertTrue(len(cmd.library_dirs) > 0)
def test_user_site(self): def test_user_site(self):
# site.USER_SITE was introduced in 2.6 # site.USER_SITE was introduced in 2.6
@ -128,7 +128,7 @@ def test_user_site(self):
# making sure the user option is there # making sure the user option is there
options = [name for name, short, lable in options = [name for name, short, lable in
cmd.user_options] cmd.user_options]
self.assert_('user' in options) self.assertTrue('user' in options)
# setting a value # setting a value
cmd.user = 1 cmd.user = 1
@ -144,9 +144,9 @@ def test_user_site(self):
# see if include_dirs and library_dirs # see if include_dirs and library_dirs
# were set # were set
self.assert_(lib in cmd.library_dirs) self.assertTrue(lib in cmd.library_dirs)
self.assert_(lib in cmd.rpath) self.assertTrue(lib in cmd.rpath)
self.assert_(incl in cmd.include_dirs) self.assertTrue(incl in cmd.include_dirs)
def test_optional_extension(self): def test_optional_extension(self):
@ -175,10 +175,10 @@ def test_finalize_options(self):
from distutils import sysconfig from distutils import sysconfig
py_include = sysconfig.get_python_inc() py_include = sysconfig.get_python_inc()
self.assert_(py_include in cmd.include_dirs) self.assertTrue(py_include in cmd.include_dirs)
plat_py_include = sysconfig.get_python_inc(plat_specific=1) plat_py_include = sysconfig.get_python_inc(plat_specific=1)
self.assert_(plat_py_include in cmd.include_dirs) self.assertTrue(plat_py_include in cmd.include_dirs)
# make sure cmd.libraries is turned into a list # make sure cmd.libraries is turned into a list
# if it's a string # if it's a string
@ -192,7 +192,7 @@ def test_finalize_options(self):
cmd = build_ext(dist) cmd = build_ext(dist)
cmd.library_dirs = 'my_lib_dir' cmd.library_dirs = 'my_lib_dir'
cmd.finalize_options() cmd.finalize_options()
self.assert_('my_lib_dir' in cmd.library_dirs) self.assertTrue('my_lib_dir' in cmd.library_dirs)
# make sure rpath is turned into a list # make sure rpath is turned into a list
# if it's a list of os.pathsep's paths # if it's a list of os.pathsep's paths
@ -257,13 +257,13 @@ def test_check_extensions_list(self):
'some': 'bar'})] 'some': 'bar'})]
cmd.check_extensions_list(exts) cmd.check_extensions_list(exts)
ext = exts[0] ext = exts[0]
self.assert_(isinstance(ext, Extension)) self.assertTrue(isinstance(ext, Extension))
# check_extensions_list adds in ext the values passed # check_extensions_list adds in ext the values passed
# when they are in ('include_dirs', 'library_dirs', 'libraries' # when they are in ('include_dirs', 'library_dirs', 'libraries'
# 'extra_objects', 'extra_compile_args', 'extra_link_args') # 'extra_objects', 'extra_compile_args', 'extra_link_args')
self.assertEquals(ext.libraries, 'foo') self.assertEquals(ext.libraries, 'foo')
self.assert_(not hasattr(ext, 'some')) self.assertTrue(not hasattr(ext, 'some'))
# 'macros' element of build info dict must be 1- or 2-tuple # 'macros' element of build info dict must be 1- or 2-tuple
exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', exts = [('foo.bar', {'sources': [''], 'libraries': 'foo',
@ -321,7 +321,7 @@ def test_get_outputs(self):
so_file = cmd.get_outputs()[0] so_file = cmd.get_outputs()[0]
finally: finally:
os.chdir(old_wd) os.chdir(old_wd)
self.assert_(os.path.exists(so_file)) self.assertTrue(os.path.exists(so_file))
self.assertEquals(os.path.splitext(so_file)[-1], self.assertEquals(os.path.splitext(so_file)[-1],
sysconfig.get_config_var('SO')) sysconfig.get_config_var('SO'))
so_dir = os.path.dirname(so_file) so_dir = os.path.dirname(so_file)
@ -330,7 +330,7 @@ def test_get_outputs(self):
cmd.inplace = 0 cmd.inplace = 0
cmd.run() cmd.run()
so_file = cmd.get_outputs()[0] so_file = cmd.get_outputs()[0]
self.assert_(os.path.exists(so_file)) self.assertTrue(os.path.exists(so_file))
self.assertEquals(os.path.splitext(so_file)[-1], self.assertEquals(os.path.splitext(so_file)[-1],
sysconfig.get_config_var('SO')) sysconfig.get_config_var('SO'))
so_dir = os.path.dirname(so_file) so_dir = os.path.dirname(so_file)

6
Lib/distutils/tests/test_build_py.py
View file

@ -52,9 +52,9 @@ def test_package_data(self):
self.assertEqual(len(cmd.get_outputs()), 3) self.assertEqual(len(cmd.get_outputs()), 3)
pkgdest = os.path.join(destination, "pkg") pkgdest = os.path.join(destination, "pkg")
files = os.listdir(pkgdest) files = os.listdir(pkgdest)
self.assert_("__init__.py" in files) self.assertTrue("__init__.py" in files)
self.assert_("__init__.pyc" in files) self.assertTrue("__init__.pyc" in files)
self.assert_("README.txt" in files) self.assertTrue("README.txt" in files)
def test_empty_package_dir (self): def test_empty_package_dir (self):
# See SF 1668596/1720897. # See SF 1668596/1720897.

10
Lib/distutils/tests/test_build_scripts.py
View file

@ -16,12 +16,12 @@ class BuildScriptsTestCase(support.TempdirManager,
def test_default_settings(self): def test_default_settings(self):
cmd = self.get_build_scripts_cmd("/foo/bar", []) cmd = self.get_build_scripts_cmd("/foo/bar", [])
self.assert_(not cmd.force) self.assertTrue(not cmd.force)
self.assert_(cmd.build_dir is None) self.assertTrue(cmd.build_dir is None)
cmd.finalize_options() cmd.finalize_options()
self.assert_(cmd.force) self.assertTrue(cmd.force)
self.assertEqual(cmd.build_dir, "/foo/bar") self.assertEqual(cmd.build_dir, "/foo/bar")
def test_build(self): def test_build(self):
@ -37,7 +37,7 @@ def test_build(self):
built = os.listdir(target) built = os.listdir(target)
for name in expected: for name in expected:
self.assert_(name in built) self.assertTrue(name in built)
def get_build_scripts_cmd(self, target, scripts): def get_build_scripts_cmd(self, target, scripts):
import sys import sys
@ -100,7 +100,7 @@ def test_version_int(self):
built = os.listdir(target) built = os.listdir(target)
for name in expected: for name in expected:
self.assert_(name in built) self.assertTrue(name in built)
def test_suite(): def test_suite():
return unittest.makeSuite(BuildScriptsTestCase) return unittest.makeSuite(BuildScriptsTestCase)

2
Lib/distutils/tests/test_clean.py
View file

@ -35,7 +35,7 @@ def test_simple_run(self):
# make sure the files where removed # make sure the files where removed
for name, path in dirs: for name, path in dirs:
self.assert_(not os.path.exists(path), self.assertTrue(not os.path.exists(path),
'%s was not removed' % path) '%s was not removed' % path)
# let's run the command again (should spit warnings but suceed) # let's run the command again (should spit warnings but suceed)

2
Lib/distutils/tests/test_cmd.py
View file

@ -70,7 +70,7 @@ def test_ensure_string(self):
cmd.option2 = None cmd.option2 = None
cmd.ensure_string('option2', 'xxx') cmd.ensure_string('option2', 'xxx')
self.assert_(hasattr(cmd, 'option2')) self.assertTrue(hasattr(cmd, 'option2'))
cmd.option3 = 1 cmd.option3 = 1
self.assertRaises(DistutilsOptionError, cmd.ensure_string, 'option3') self.assertRaises(DistutilsOptionError, cmd.ensure_string, 'option3')

4
Lib/distutils/tests/test_config.py
View file

@ -102,9 +102,9 @@ def test_server_registration(self):
def test_server_empty_registration(self): def test_server_empty_registration(self):
cmd = self._cmd(self.dist) cmd = self._cmd(self.dist)
rc = cmd._get_rc_file() rc = cmd._get_rc_file()
self.assert_(not os.path.exists(rc)) self.assertTrue(not os.path.exists(rc))
cmd._store_pypirc('tarek', 'xxx') cmd._store_pypirc('tarek', 'xxx')
self.assert_(os.path.exists(rc)) self.assertTrue(os.path.exists(rc))
content = open(rc).read() content = open(rc).read()
self.assertEquals(content, WANTED) self.assertEquals(content, WANTED)

4
Lib/distutils/tests/test_config_cmd.py
View file

@ -73,14 +73,14 @@ def test_clean(self):
self.write_file(f2, 'xxx') self.write_file(f2, 'xxx')
for f in (f1, f2): for f in (f1, f2):
self.assert_(os.path.exists(f)) self.assertTrue(os.path.exists(f))
pkg_dir, dist = self.create_dist() pkg_dir, dist = self.create_dist()
cmd = config(dist) cmd = config(dist)
cmd._clean(f1, f2) cmd._clean(f1, f2)
for f in (f1, f2): for f in (f1, f2):
self.assert_(not os.path.exists(f)) self.assertTrue(not os.path.exists(f))
def test_suite(): def test_suite():
return unittest.makeSuite(ConfigTestCase) return unittest.makeSuite(ConfigTestCase)

42
Lib/distutils/tests/test_dist.py
View file

@ -72,7 +72,7 @@ def test_command_packages_cmdline(self):
self.assertEqual(d.get_command_packages(), self.assertEqual(d.get_command_packages(),
["distutils.command", "foo.bar", "distutils.tests"]) ["distutils.command", "foo.bar", "distutils.tests"])
cmd = d.get_command_obj("test_dist") cmd = d.get_command_obj("test_dist")
self.assert_(isinstance(cmd, test_dist)) self.assertTrue(isinstance(cmd, test_dist))
self.assertEqual(cmd.sample_option, "sometext") self.assertEqual(cmd.sample_option, "sometext")
def test_command_packages_configfile(self): def test_command_packages_configfile(self):
@ -175,10 +175,10 @@ def test_simple_metadata(self):
"version": "1.0"} "version": "1.0"}
dist = Distribution(attrs) dist = Distribution(attrs)
meta = self.format_metadata(dist) meta = self.format_metadata(dist)
self.assert_("Metadata-Version: 1.0" in meta) self.assertTrue("Metadata-Version: 1.0" in meta)
self.assert_("provides:" not in meta.lower()) self.assertTrue("provides:" not in meta.lower())
self.assert_("requires:" not in meta.lower()) self.assertTrue("requires:" not in meta.lower())
self.assert_("obsoletes:" not in meta.lower()) self.assertTrue("obsoletes:" not in meta.lower())
def test_provides(self): def test_provides(self):
attrs = {"name": "package", attrs = {"name": "package",
@ -190,9 +190,9 @@ def test_provides(self):
self.assertEqual(dist.get_provides(), self.assertEqual(dist.get_provides(),
["package", "package.sub"]) ["package", "package.sub"])
meta = self.format_metadata(dist) meta = self.format_metadata(dist)
self.assert_("Metadata-Version: 1.1" in meta) self.assertTrue("Metadata-Version: 1.1" in meta)
self.assert_("requires:" not in meta.lower()) self.assertTrue("requires:" not in meta.lower())
self.assert_("obsoletes:" not in meta.lower()) self.assertTrue("obsoletes:" not in meta.lower())
def test_provides_illegal(self): def test_provides_illegal(self):
self.assertRaises(ValueError, Distribution, self.assertRaises(ValueError, Distribution,
@ -210,11 +210,11 @@ def test_requires(self):
self.assertEqual(dist.get_requires(), self.assertEqual(dist.get_requires(),
["other", "another (==1.0)"]) ["other", "another (==1.0)"])
meta = self.format_metadata(dist) meta = self.format_metadata(dist)
self.assert_("Metadata-Version: 1.1" in meta) self.assertTrue("Metadata-Version: 1.1" in meta)
self.assert_("provides:" not in meta.lower()) self.assertTrue("provides:" not in meta.lower())
self.assert_("Requires: other" in meta) self.assertTrue("Requires: other" in meta)
self.assert_("Requires: another (==1.0)" in meta) self.assertTrue("Requires: another (==1.0)" in meta)
self.assert_("obsoletes:" not in meta.lower()) self.assertTrue("obsoletes:" not in meta.lower())
def test_requires_illegal(self): def test_requires_illegal(self):
self.assertRaises(ValueError, Distribution, self.assertRaises(ValueError, Distribution,
@ -232,11 +232,11 @@ def test_obsoletes(self):
self.assertEqual(dist.get_obsoletes(), self.assertEqual(dist.get_obsoletes(),
["other", "another (<1.0)"]) ["other", "another (<1.0)"])
meta = self.format_metadata(dist) meta = self.format_metadata(dist)
self.assert_("Metadata-Version: 1.1" in meta) self.assertTrue("Metadata-Version: 1.1" in meta)
self.assert_("provides:" not in meta.lower()) self.assertTrue("provides:" not in meta.lower())
self.assert_("requires:" not in meta.lower()) self.assertTrue("requires:" not in meta.lower())
self.assert_("Obsoletes: other" in meta) self.assertTrue("Obsoletes: other" in meta)
self.assert_("Obsoletes: another (<1.0)" in meta) self.assertTrue("Obsoletes: another (<1.0)" in meta)
def test_obsoletes_illegal(self): def test_obsoletes_illegal(self):
self.assertRaises(ValueError, Distribution, self.assertRaises(ValueError, Distribution,
@ -270,14 +270,14 @@ def test_custom_pydistutils(self):
if sys.platform in ('linux', 'darwin'): if sys.platform in ('linux', 'darwin'):
self.environ['HOME'] = temp_dir self.environ['HOME'] = temp_dir
files = dist.find_config_files() files = dist.find_config_files()
self.assert_(user_filename in files) self.assertTrue(user_filename in files)
# win32-style # win32-style
if sys.platform == 'win32': if sys.platform == 'win32':
# home drive should be found # home drive should be found
self.environ['HOME'] = temp_dir self.environ['HOME'] = temp_dir
files = dist.find_config_files() files = dist.find_config_files()
self.assert_(user_filename in files, self.assertTrue(user_filename in files,
'%r not found in %r' % (user_filename, files)) '%r not found in %r' % (user_filename, files))
finally: finally:
os.remove(user_filename) os.remove(user_filename)
@ -303,7 +303,7 @@ def test_show_help(self):
output = [line for line in s.getvalue().split('\n') output = [line for line in s.getvalue().split('\n')
if line.strip() != ''] if line.strip() != '']
self.assert_(len(output) > 0) self.assertTrue(len(output) > 0)
def test_suite(): def test_suite():
suite = unittest.TestSuite() suite = unittest.TestSuite()

16
Lib/distutils/tests/test_install.py
View file

@ -88,7 +88,7 @@ def _expanduser(path):
def _test_user_site(self): def _test_user_site(self):
for key in ('nt_user', 'unix_user', 'os2_home'): for key in ('nt_user', 'unix_user', 'os2_home'):
self.assert_(key in INSTALL_SCHEMES) self.assertTrue(key in INSTALL_SCHEMES)
dist = Distribution({'name': 'xx'}) dist = Distribution({'name': 'xx'})
cmd = install(dist) cmd = install(dist)
@ -96,24 +96,24 @@ def _test_user_site(self):
# making sure the user option is there # making sure the user option is there
options = [name for name, short, lable in options = [name for name, short, lable in
cmd.user_options] cmd.user_options]
self.assert_('user' in options) self.assertTrue('user' in options)
# setting a value # setting a value
cmd.user = 1 cmd.user = 1
# user base and site shouldn't be created yet # user base and site shouldn't be created yet
self.assert_(not os.path.exists(self.user_base)) self.assertTrue(not os.path.exists(self.user_base))
self.assert_(not os.path.exists(self.user_site)) self.assertTrue(not os.path.exists(self.user_site))
# let's run finalize # let's run finalize
cmd.ensure_finalized() cmd.ensure_finalized()
# now they should # now they should
self.assert_(os.path.exists(self.user_base)) self.assertTrue(os.path.exists(self.user_base))
self.assert_(os.path.exists(self.user_site)) self.assertTrue(os.path.exists(self.user_site))
self.assert_('userbase' in cmd.config_vars) self.assertTrue('userbase' in cmd.config_vars)
self.assert_('usersite' in cmd.config_vars) self.assertTrue('usersite' in cmd.config_vars)
def test_handle_extra_path(self): def test_handle_extra_path(self):
dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'}) dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})

12
Lib/distutils/tests/test_install_data.py
View file

@ -35,9 +35,9 @@ def test_simple_run(self):
# let's check the result # let's check the result
self.assertEquals(len(cmd.get_outputs()), 2) self.assertEquals(len(cmd.get_outputs()), 2)
rtwo = os.path.split(two)[-1] rtwo = os.path.split(two)[-1]
self.assert_(os.path.exists(os.path.join(inst2, rtwo))) self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
rone = os.path.split(one)[-1] rone = os.path.split(one)[-1]
self.assert_(os.path.exists(os.path.join(inst, rone))) self.assertTrue(os.path.exists(os.path.join(inst, rone)))
cmd.outfiles = [] cmd.outfiles = []
# let's try with warn_dir one # let's try with warn_dir one
@ -47,8 +47,8 @@ def test_simple_run(self):
# let's check the result # let's check the result
self.assertEquals(len(cmd.get_outputs()), 2) self.assertEquals(len(cmd.get_outputs()), 2)
self.assert_(os.path.exists(os.path.join(inst2, rtwo))) self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
self.assert_(os.path.exists(os.path.join(inst, rone))) self.assertTrue(os.path.exists(os.path.join(inst, rone)))
cmd.outfiles = [] cmd.outfiles = []
# now using root and empty dir # now using root and empty dir
@ -65,8 +65,8 @@ def test_simple_run(self):
# let's check the result # let's check the result
self.assertEquals(len(cmd.get_outputs()), 4) self.assertEquals(len(cmd.get_outputs()), 4)
self.assert_(os.path.exists(os.path.join(inst2, rtwo))) self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
self.assert_(os.path.exists(os.path.join(inst, rone))) self.assertTrue(os.path.exists(os.path.join(inst, rone)))
def test_suite(): def test_suite():
return unittest.makeSuite(InstallDataTestCase) return unittest.makeSuite(InstallDataTestCase)

6
Lib/distutils/tests/test_install_lib.py
View file

@ -39,8 +39,8 @@ def test_byte_compile(self):
f = os.path.join(pkg_dir, 'foo.py') f = os.path.join(pkg_dir, 'foo.py')
self.write_file(f, '# python file') self.write_file(f, '# python file')
cmd.byte_compile([f]) cmd.byte_compile([f])
self.assert_(os.path.exists(os.path.join(pkg_dir, 'foo.pyc'))) self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'foo.pyc')))
self.assert_(os.path.exists(os.path.join(pkg_dir, 'foo.pyo'))) self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'foo.pyo')))
def test_get_outputs(self): def test_get_outputs(self):
pkg_dir, dist = self.create_dist() pkg_dir, dist = self.create_dist()
@ -57,7 +57,7 @@ def test_get_outputs(self):
cmd.distribution.script_name = 'setup.py' cmd.distribution.script_name = 'setup.py'
# get_output should return 4 elements # get_output should return 4 elements
self.assert_(len(cmd.get_outputs()) >= 2) self.assertTrue(len(cmd.get_outputs()) >= 2)
def test_get_inputs(self): def test_get_inputs(self):
pkg_dir, dist = self.create_dist() pkg_dir, dist = self.create_dist()

14
Lib/distutils/tests/test_install_scripts.py
View file

@ -23,15 +23,15 @@ def test_default_settings(self):
skip_build=1, skip_build=1,
) )
cmd = install_scripts(dist) cmd = install_scripts(dist)
self.assert_(not cmd.force) self.assertTrue(not cmd.force)
self.assert_(not cmd.skip_build) self.assertTrue(not cmd.skip_build)
self.assert_(cmd.build_dir is None) self.assertTrue(cmd.build_dir is None)
self.assert_(cmd.install_dir is None) self.assertTrue(cmd.install_dir is None)
cmd.finalize_options() cmd.finalize_options()
self.assert_(cmd.force) self.assertTrue(cmd.force)
self.assert_(cmd.skip_build) self.assertTrue(cmd.skip_build)
self.assertEqual(cmd.build_dir, "/foo/bar") self.assertEqual(cmd.build_dir, "/foo/bar")
self.assertEqual(cmd.install_dir, "/splat/funk") self.assertEqual(cmd.install_dir, "/splat/funk")
@ -69,7 +69,7 @@ def write_script(name, text):
installed = os.listdir(target) installed = os.listdir(target)
for name in expected: for name in expected:
self.assert_(name in installed) self.assertTrue(name in installed)
def test_suite(): def test_suite():

4
Lib/distutils/tests/test_msvc9compiler.py
View file

@ -46,7 +46,7 @@ def test_reg_class(self):
# windows registeries versions. # windows registeries versions.
path = r'Software\Microsoft\Notepad' path = r'Software\Microsoft\Notepad'
v = Reg.get_value(path, "lfitalic") v = Reg.get_value(path, "lfitalic")
self.assert_(v in (0, 1)) self.assertTrue(v in (0, 1))
import winreg import winreg
HKCU = winreg.HKEY_CURRENT_USER HKCU = winreg.HKEY_CURRENT_USER
@ -54,7 +54,7 @@ def test_reg_class(self):
self.assertEquals(keys, None) self.assertEquals(keys, None)
keys = Reg.read_keys(HKCU, r'Software\Microsoft') keys = Reg.read_keys(HKCU, r'Software\Microsoft')
self.assert_('Notepad' in keys) self.assertTrue('Notepad' in keys)
def test_suite(): def test_suite():
return unittest.makeSuite(msvc9compilerTestCase) return unittest.makeSuite(msvc9compilerTestCase)

16
Lib/distutils/tests/test_register.py
View file

@ -96,7 +96,7 @@ def test_create_pypirc(self):
cmd = self._get_cmd() cmd = self._get_cmd()
# we shouldn't have a .pypirc file yet # we shouldn't have a .pypirc file yet
self.assert_(not os.path.exists(self.rc)) self.assertTrue(not os.path.exists(self.rc))
# patching input and getpass.getpass # patching input and getpass.getpass
# so register gets happy # so register gets happy
@ -115,7 +115,7 @@ def test_create_pypirc(self):
del register_module.input del register_module.input
# we should have a brand new .pypirc file # we should have a brand new .pypirc file
self.assert_(os.path.exists(self.rc)) self.assertTrue(os.path.exists(self.rc))
# with the content similar to WANTED_PYPIRC # with the content similar to WANTED_PYPIRC
content = open(self.rc).read() content = open(self.rc).read()
@ -133,13 +133,13 @@ def _no_way(prompt=''):
# let's see what the server received : we should # let's see what the server received : we should
# have 2 similar requests # have 2 similar requests
self.assert_(self.conn.reqs, 2) self.assertTrue(self.conn.reqs, 2)
req1 = dict(self.conn.reqs[0].headers) req1 = dict(self.conn.reqs[0].headers)
req2 = dict(self.conn.reqs[1].headers) req2 = dict(self.conn.reqs[1].headers)
self.assertEquals(req1['Content-length'], '1374') self.assertEquals(req1['Content-length'], '1374')
self.assertEquals(req2['Content-length'], '1374') self.assertEquals(req2['Content-length'], '1374')
self.assert_((b'xxx') in self.conn.reqs[1].data) self.assertTrue((b'xxx') in self.conn.reqs[1].data)
def test_password_not_in_file(self): def test_password_not_in_file(self):
@ -165,11 +165,11 @@ def test_registering(self):
del register_module.input del register_module.input
# we should have send a request # we should have send a request
self.assert_(self.conn.reqs, 1) self.assertTrue(self.conn.reqs, 1)
req = self.conn.reqs[0] req = self.conn.reqs[0]
headers = dict(req.headers) headers = dict(req.headers)
self.assertEquals(headers['Content-length'], '608') self.assertEquals(headers['Content-length'], '608')
self.assert_((b'tarek') in req.data) self.assertTrue((b'tarek') in req.data)
def test_password_reset(self): def test_password_reset(self):
# this test runs choice 3 # this test runs choice 3
@ -183,11 +183,11 @@ def test_password_reset(self):
del register_module.input del register_module.input
# we should have send a request # we should have send a request
self.assert_(self.conn.reqs, 1) self.assertTrue(self.conn.reqs, 1)
req = self.conn.reqs[0] req = self.conn.reqs[0]
headers = dict(req.headers) headers = dict(req.headers)
self.assertEquals(headers['Content-length'], '290') self.assertEquals(headers['Content-length'], '290')
self.assert_((b'tarek') in req.data) self.assertTrue((b'tarek') in req.data)
def test_strict(self): def test_strict(self):
# testing the script option # testing the script option

12
Lib/distutils/tests/test_sysconfig.py
View file

@ -21,12 +21,12 @@ def tearDown(self):
def test_get_config_h_filename(self): def test_get_config_h_filename(self):
config_h = sysconfig.get_config_h_filename() config_h = sysconfig.get_config_h_filename()
self.assert_(os.path.isfile(config_h), config_h) self.assertTrue(os.path.isfile(config_h), config_h)
def test_get_python_lib(self): def test_get_python_lib(self):
lib_dir = sysconfig.get_python_lib() lib_dir = sysconfig.get_python_lib()
# XXX doesn't work on Linux when Python was never installed before # XXX doesn't work on Linux when Python was never installed before
#self.assert_(os.path.isdir(lib_dir), lib_dir) #self.assertTrue(os.path.isdir(lib_dir), lib_dir)
# test for pythonxx.lib? # test for pythonxx.lib?
self.assertNotEqual(sysconfig.get_python_lib(), self.assertNotEqual(sysconfig.get_python_lib(),
sysconfig.get_python_lib(prefix=TESTFN)) sysconfig.get_python_lib(prefix=TESTFN))
@ -36,14 +36,14 @@ def test_get_python_inc(self):
# This is not much of a test. We make sure Python.h exists # This is not much of a test. We make sure Python.h exists
# in the directory returned by get_python_inc() but we don't know # in the directory returned by get_python_inc() but we don't know
# it is the correct file. # it is the correct file.
self.assert_(os.path.isdir(inc_dir), inc_dir) self.assertTrue(os.path.isdir(inc_dir), inc_dir)
python_h = os.path.join(inc_dir, "Python.h") python_h = os.path.join(inc_dir, "Python.h")
self.assert_(os.path.isfile(python_h), python_h) self.assertTrue(os.path.isfile(python_h), python_h)
def test_get_config_vars(self): def test_get_config_vars(self):
cvars = sysconfig.get_config_vars() cvars = sysconfig.get_config_vars()
self.assert_(isinstance(cvars, dict)) self.assertTrue(isinstance(cvars, dict))
self.assert_(cvars) self.assertTrue(cvars)
def test_customize_compiler(self): def test_customize_compiler(self):

4
Lib/distutils/tests/test_upload.py
View file

@ -96,11 +96,11 @@ def test_upload(self):
# what did we send ? # what did we send ?
headers = dict(self.last_open.req.headers) headers = dict(self.last_open.req.headers)
self.assertEquals(headers['Content-length'], '2087') self.assertEquals(headers['Content-length'], '2087')
self.assert_(headers['Content-type'].startswith('multipart/form-data')) self.assertTrue(headers['Content-type'].startswith('multipart/form-data'))
self.assertEquals(self.last_open.req.get_method(), 'POST') self.assertEquals(self.last_open.req.get_method(), 'POST')
self.assertEquals(self.last_open.req.get_full_url(), self.assertEquals(self.last_open.req.get_full_url(),
'http://pypi.python.org/pypi') 'http://pypi.python.org/pypi')
self.assert_(b'xxx' in self.last_open.req.data) self.assertTrue(b'xxx' in self.last_open.req.data)
def test_suite(): def test_suite():
return unittest.makeSuite(uploadTestCase) return unittest.makeSuite(uploadTestCase)

4
Lib/distutils/tests/test_util.py
View file

@ -225,10 +225,10 @@ def test_strtobool(self):
no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N') no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')
for y in yes: for y in yes:
self.assert_(strtobool(y)) self.assertTrue(strtobool(y))
for n in no: for n in no:
self.assert_(not strtobool(n)) self.assertTrue(not strtobool(n))
def test_rfc822_escape(self): def test_rfc822_escape(self):
header = 'I am a\npoor\nlonesome\nheader\n' header = 'I am a\npoor\nlonesome\nheader\n'

86
Lib/email/test/test_email.py
View file

@ -53,7 +53,7 @@ def openfile(filename, *args, **kws):
# Base test class # Base test class
class TestEmailBase(unittest.TestCase): class TestEmailBase(unittest.TestCase):
def ndiffAssertEqual(self, first, second): def ndiffAssertEqual(self, first, second):
"""Like failUnlessEqual except use ndiff for readable output.""" """Like assertEqual except use ndiff for readable output."""
if first != second: if first != second:
sfirst = str(first) sfirst = str(first)
ssecond = str(second) ssecond = str(second)
@ -222,12 +222,12 @@ def test__contains__(self):
msg['From'] = 'Me' msg['From'] = 'Me'
msg['to'] = 'You' msg['to'] = 'You'
# Check for case insensitivity # Check for case insensitivity
self.failUnless('from' in msg) self.assertTrue('from' in msg)
self.failUnless('From' in msg) self.assertTrue('From' in msg)
self.failUnless('FROM' in msg) self.assertTrue('FROM' in msg)
self.failUnless('to' in msg) self.assertTrue('to' in msg)
self.failUnless('To' in msg) self.assertTrue('To' in msg)
self.failUnless('TO' in msg) self.assertTrue('TO' in msg)
def test_as_string(self): def test_as_string(self):
eq = self.ndiffAssertEqual eq = self.ndiffAssertEqual
@ -237,7 +237,7 @@ def test_as_string(self):
eq(text, str(msg)) eq(text, str(msg))
fullrepr = msg.as_string(unixfrom=True) fullrepr = msg.as_string(unixfrom=True)
lines = fullrepr.split('\n') lines = fullrepr.split('\n')
self.failUnless(lines[0].startswith('From ')) self.assertTrue(lines[0].startswith('From '))
eq(text, NL.join(lines[1:])) eq(text, NL.join(lines[1:]))
def test_bad_param(self): def test_bad_param(self):
@ -307,12 +307,12 @@ def test_get_param_with_semis_in_quotes(self):
'"Jim&amp;&amp;Jill"') '"Jim&amp;&amp;Jill"')
def test_field_containment(self): def test_field_containment(self):
unless = self.failUnless unless = self.assertTrue
msg = email.message_from_string('Header: exists') msg = email.message_from_string('Header: exists')
unless('header' in msg) unless('header' in msg)
unless('Header' in msg) unless('Header' in msg)
unless('HEADER' in msg) unless('HEADER' in msg)
self.failIf('headerx' in msg) self.assertFalse('headerx' in msg)
def test_set_param(self): def test_set_param(self):
eq = self.assertEqual eq = self.assertEqual
@ -952,7 +952,7 @@ def test_checkSetMinor(self):
def test_add_header(self): def test_add_header(self):
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
self._au.add_header('Content-Disposition', 'attachment', self._au.add_header('Content-Disposition', 'attachment',
filename='audiotest.au') filename='audiotest.au')
eq(self._au['content-disposition'], eq(self._au['content-disposition'],
@ -992,7 +992,7 @@ def test_checkSetMinor(self):
def test_add_header(self): def test_add_header(self):
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
self._im.add_header('Content-Disposition', 'attachment', self._im.add_header('Content-Disposition', 'attachment',
filename='dingusfish.gif') filename='dingusfish.gif')
eq(self._im['content-disposition'], eq(self._im['content-disposition'],
@ -1036,7 +1036,7 @@ def setUp(self):
def test_types(self): def test_types(self):
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
eq(self._msg.get_content_type(), 'text/plain') eq(self._msg.get_content_type(), 'text/plain')
eq(self._msg.get_param('charset'), 'us-ascii') eq(self._msg.get_param('charset'), 'us-ascii')
missing = [] missing = []
@ -1046,7 +1046,7 @@ def test_types(self):
def test_payload(self): def test_payload(self):
self.assertEqual(self._msg.get_payload(), 'hello there') self.assertEqual(self._msg.get_payload(), 'hello there')
self.failUnless(not self._msg.is_multipart()) self.assertTrue(not self._msg.is_multipart())
def test_charset(self): def test_charset(self):
eq = self.assertEqual eq = self.assertEqual
@ -1097,7 +1097,7 @@ def setUp(self):
def test_hierarchy(self): def test_hierarchy(self):
# convenience # convenience
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
raises = self.assertRaises raises = self.assertRaises
# tests # tests
m = self._msg m = self._msg
@ -1411,7 +1411,7 @@ def test_boundary_with_leading_space(self):
-- XXXX-- -- XXXX--
''') ''')
self.failUnless(msg.is_multipart()) self.assertTrue(msg.is_multipart())
eq(msg.get_boundary(), ' XXXX') eq(msg.get_boundary(), ' XXXX')
eq(len(msg.get_payload()), 2) eq(len(msg.get_payload()), 2)
@ -1441,7 +1441,7 @@ def test_parse_missing_minor_type(self):
eq(msg.get_content_subtype(), 'plain') eq(msg.get_content_subtype(), 'plain')
def test_same_boundary_inner_outer(self): def test_same_boundary_inner_outer(self):
unless = self.failUnless unless = self.assertTrue
msg = self._msgobj('msg_15.txt') msg = self._msgobj('msg_15.txt')
# XXX We can probably eventually do better # XXX We can probably eventually do better
inner = msg.get_payload(0) inner = msg.get_payload(0)
@ -1451,7 +1451,7 @@ def test_same_boundary_inner_outer(self):
errors.StartBoundaryNotFoundDefect)) errors.StartBoundaryNotFoundDefect))
def test_multipart_no_boundary(self): def test_multipart_no_boundary(self):
unless = self.failUnless unless = self.assertTrue
msg = self._msgobj('msg_25.txt') msg = self._msgobj('msg_25.txt')
unless(isinstance(msg.get_payload(), str)) unless(isinstance(msg.get_payload(), str))
self.assertEqual(len(msg.defects), 2) self.assertEqual(len(msg.defects), 2)
@ -1509,7 +1509,7 @@ def test_no_separating_blank_line(self):
""") """)
def test_lying_multipart(self): def test_lying_multipart(self):
unless = self.failUnless unless = self.assertTrue
msg = self._msgobj('msg_41.txt') msg = self._msgobj('msg_41.txt')
unless(hasattr(msg, 'defects')) unless(hasattr(msg, 'defects'))
self.assertEqual(len(msg.defects), 2) self.assertEqual(len(msg.defects), 2)
@ -1529,7 +1529,7 @@ def test_missing_start_boundary(self):
# [*] This message is missing its start boundary # [*] This message is missing its start boundary
bad = outer.get_payload(1).get_payload(0) bad = outer.get_payload(1).get_payload(0)
self.assertEqual(len(bad.defects), 1) self.assertEqual(len(bad.defects), 1)
self.failUnless(isinstance(bad.defects[0], self.assertTrue(isinstance(bad.defects[0],
errors.StartBoundaryNotFoundDefect)) errors.StartBoundaryNotFoundDefect))
def test_first_line_is_continuation_header(self): def test_first_line_is_continuation_header(self):
@ -1539,7 +1539,7 @@ def test_first_line_is_continuation_header(self):
eq(msg.keys(), []) eq(msg.keys(), [])
eq(msg.get_payload(), 'Line 2\nLine 3') eq(msg.get_payload(), 'Line 2\nLine 3')
eq(len(msg.defects), 1) eq(len(msg.defects), 1)
self.failUnless(isinstance(msg.defects[0], self.assertTrue(isinstance(msg.defects[0],
errors.FirstHeaderLineIsContinuationDefect)) errors.FirstHeaderLineIsContinuationDefect))
eq(msg.defects[0].line, ' Line 1\n') eq(msg.defects[0].line, ' Line 1\n')
@ -1607,7 +1607,7 @@ def test_type_error(self):
def test_valid_argument(self): def test_valid_argument(self):
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
subject = 'A sub-message' subject = 'A sub-message'
m = Message() m = Message()
m['Subject'] = subject m['Subject'] = subject
@ -1651,20 +1651,20 @@ def test_generate(self):
def test_parse_message_rfc822(self): def test_parse_message_rfc822(self):
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
msg = self._msgobj('msg_11.txt') msg = self._msgobj('msg_11.txt')
eq(msg.get_content_type(), 'message/rfc822') eq(msg.get_content_type(), 'message/rfc822')
payload = msg.get_payload() payload = msg.get_payload()
unless(isinstance(payload, list)) unless(isinstance(payload, list))
eq(len(payload), 1) eq(len(payload), 1)
submsg = payload[0] submsg = payload[0]
self.failUnless(isinstance(submsg, Message)) self.assertTrue(isinstance(submsg, Message))
eq(submsg['subject'], 'An enclosed message') eq(submsg['subject'], 'An enclosed message')
eq(submsg.get_payload(), 'Here is the body of the message.\n') eq(submsg.get_payload(), 'Here is the body of the message.\n')
def test_dsn(self): def test_dsn(self):
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
# msg 16 is a Delivery Status Notification, see RFC 1894 # msg 16 is a Delivery Status Notification, see RFC 1894
msg = self._msgobj('msg_16.txt') msg = self._msgobj('msg_16.txt')
eq(msg.get_content_type(), 'multipart/report') eq(msg.get_content_type(), 'multipart/report')
@ -2002,7 +2002,7 @@ def test_message_external_body_idempotent(self):
def test_content_type(self): def test_content_type(self):
eq = self.assertEquals eq = self.assertEquals
unless = self.failUnless unless = self.assertTrue
# Get a message object and reset the seek pointer for other tests # Get a message object and reset the seek pointer for other tests
msg, text = self._msgobj('msg_05.txt') msg, text = self._msgobj('msg_05.txt')
eq(msg.get_content_type(), 'multipart/report') eq(msg.get_content_type(), 'multipart/report')
@ -2024,7 +2024,7 @@ def test_content_type(self):
eq(msg2.get_payload(), 'Yadda yadda yadda\n') eq(msg2.get_payload(), 'Yadda yadda yadda\n')
msg3 = msg.get_payload(2) msg3 = msg.get_payload(2)
eq(msg3.get_content_type(), 'message/rfc822') eq(msg3.get_content_type(), 'message/rfc822')
self.failUnless(isinstance(msg3, Message)) self.assertTrue(isinstance(msg3, Message))
payload = msg3.get_payload() payload = msg3.get_payload()
unless(isinstance(payload, list)) unless(isinstance(payload, list))
eq(len(payload), 1) eq(len(payload), 1)
@ -2034,7 +2034,7 @@ def test_content_type(self):
def test_parser(self): def test_parser(self):
eq = self.assertEquals eq = self.assertEquals
unless = self.failUnless unless = self.assertTrue
msg, text = self._msgobj('msg_06.txt') msg, text = self._msgobj('msg_06.txt')
# Check some of the outer headers # Check some of the outer headers
eq(msg.get_content_type(), 'message/rfc822') eq(msg.get_content_type(), 'message/rfc822')
@ -2044,9 +2044,9 @@ def test_parser(self):
unless(isinstance(payload, list)) unless(isinstance(payload, list))
eq(len(payload), 1) eq(len(payload), 1)
msg1 = payload[0] msg1 = payload[0]
self.failUnless(isinstance(msg1, Message)) self.assertTrue(isinstance(msg1, Message))
eq(msg1.get_content_type(), 'text/plain') eq(msg1.get_content_type(), 'text/plain')
self.failUnless(isinstance(msg1.get_payload(), str)) self.assertTrue(isinstance(msg1.get_payload(), str))
eq(msg1.get_payload(), '\n') eq(msg1.get_payload(), '\n')
@ -2077,7 +2077,7 @@ def test_message_from_file(self):
self.assertEqual(text, s.getvalue()) self.assertEqual(text, s.getvalue())
def test_message_from_string_with_class(self): def test_message_from_string_with_class(self):
unless = self.failUnless unless = self.assertTrue
with openfile('msg_01.txt') as fp: with openfile('msg_01.txt') as fp:
text = fp.read() text = fp.read()
@ -2095,7 +2095,7 @@ class MyMessage(Message):
unless(isinstance(subpart, MyMessage)) unless(isinstance(subpart, MyMessage))
def test_message_from_file_with_class(self): def test_message_from_file_with_class(self):
unless = self.failUnless unless = self.assertTrue
# Create a subclass # Create a subclass
class MyMessage(Message): class MyMessage(Message):
pass pass
@ -2217,7 +2217,7 @@ def test_quote_dump(self):
def test_charset_richcomparisons(self): def test_charset_richcomparisons(self):
eq = self.assertEqual eq = self.assertEqual
ne = self.failIfEqual ne = self.assertNotEqual
cset1 = Charset() cset1 = Charset()
cset2 = Charset() cset2 = Charset()
eq(cset1, 'us-ascii') eq(cset1, 'us-ascii')
@ -2410,8 +2410,8 @@ def test_header_parser(self):
eq(msg['from'], 'ppp-request@zzz.org') eq(msg['from'], 'ppp-request@zzz.org')
eq(msg['to'], 'ppp@zzz.org') eq(msg['to'], 'ppp@zzz.org')
eq(msg.get_content_type(), 'multipart/mixed') eq(msg.get_content_type(), 'multipart/mixed')
self.failIf(msg.is_multipart()) self.assertFalse(msg.is_multipart())
self.failUnless(isinstance(msg.get_payload(), str)) self.assertTrue(isinstance(msg.get_payload(), str))
def test_whitespace_continuation(self): def test_whitespace_continuation(self):
eq = self.assertEqual eq = self.assertEqual
@ -2613,18 +2613,18 @@ def setUp(self):
def test_quopri_header_check(self): def test_quopri_header_check(self):
for c in self.hlit: for c in self.hlit:
self.failIf(quoprimime.header_check(c), self.assertFalse(quoprimime.header_check(c),
'Should not be header quopri encoded: %s' % chr(c)) 'Should not be header quopri encoded: %s' % chr(c))
for c in self.hnon: for c in self.hnon:
self.failUnless(quoprimime.header_check(c), self.assertTrue(quoprimime.header_check(c),
'Should be header quopri encoded: %s' % chr(c)) 'Should be header quopri encoded: %s' % chr(c))
def test_quopri_body_check(self): def test_quopri_body_check(self):
for c in self.blit: for c in self.blit:
self.failIf(quoprimime.body_check(c), self.assertFalse(quoprimime.body_check(c),
'Should not be body quopri encoded: %s' % chr(c)) 'Should not be body quopri encoded: %s' % chr(c))
for c in self.bnon: for c in self.bnon:
self.failUnless(quoprimime.body_check(c), self.assertTrue(quoprimime.body_check(c),
'Should be body quopri encoded: %s' % chr(c)) 'Should be body quopri encoded: %s' % chr(c))
def test_header_quopri_len(self): def test_header_quopri_len(self):
@ -2789,7 +2789,7 @@ def test_long(self):
h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.", h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.",
maxlinelen=76) maxlinelen=76)
for l in h.encode(splitchars=' ').split('\n '): for l in h.encode(splitchars=' ').split('\n '):
self.failUnless(len(l) <= 76) self.assertTrue(len(l) <= 76)
def test_multilingual(self): def test_multilingual(self):
eq = self.ndiffAssertEqual eq = self.ndiffAssertEqual
@ -3166,7 +3166,7 @@ def test_rfc2231_no_language_or_charset(self):
''' '''
msg = email.message_from_string(m) msg = email.message_from_string(m)
param = msg.get_param('NAME') param = msg.get_param('NAME')
self.failIf(isinstance(param, tuple)) self.assertFalse(isinstance(param, tuple))
self.assertEqual( self.assertEqual(
param, param,
'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm') 'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm')
@ -3319,7 +3319,7 @@ def test_rfc2231_single_tick_in_filename(self):
""" """
msg = email.message_from_string(m) msg = email.message_from_string(m)
param = msg.get_param('name') param = msg.get_param('name')
self.failIf(isinstance(param, tuple)) self.assertFalse(isinstance(param, tuple))
self.assertEqual(param, "Frank's Document") self.assertEqual(param, "Frank's Document")
def test_rfc2231_tick_attack_extended(self): def test_rfc2231_tick_attack_extended(self):
@ -3343,7 +3343,7 @@ def test_rfc2231_tick_attack(self):
""" """
msg = email.message_from_string(m) msg = email.message_from_string(m)
param = msg.get_param('name') param = msg.get_param('name')
self.failIf(isinstance(param, tuple)) self.assertFalse(isinstance(param, tuple))
self.assertEqual(param, "us-ascii'en-us'Frank's Document") self.assertEqual(param, "us-ascii'en-us'Frank's Document")
def test_rfc2231_no_extended_values(self): def test_rfc2231_no_extended_values(self):

6
Lib/importlib/test/builtin/test_finder.py
View file

@ -14,7 +14,7 @@ def test_module(self):
# Common case. # Common case.
with util.uncache(builtin_util.NAME): with util.uncache(builtin_util.NAME):
found = machinery.BuiltinImporter.find_module(builtin_util.NAME) found = machinery.BuiltinImporter.find_module(builtin_util.NAME)
self.assert_(found) self.assertTrue(found)
def test_package(self): def test_package(self):
# Built-in modules cannot be a package. # Built-in modules cannot be a package.
@ -35,14 +35,14 @@ def test_package_over_module(self):
def test_failure(self): def test_failure(self):
assert 'importlib' not in sys.builtin_module_names assert 'importlib' not in sys.builtin_module_names
loader = machinery.BuiltinImporter.find_module('importlib') loader = machinery.BuiltinImporter.find_module('importlib')
self.assert_(loader is None) self.assertTrue(loader is None)
def test_ignore_path(self): def test_ignore_path(self):
# The value for 'path' should always trigger a failed import. # The value for 'path' should always trigger a failed import.
with util.uncache(builtin_util.NAME): with util.uncache(builtin_util.NAME):
loader = machinery.BuiltinImporter.find_module(builtin_util.NAME, loader = machinery.BuiltinImporter.find_module(builtin_util.NAME,
['pkg']) ['pkg'])
self.assert_(loader is None) self.assertTrue(loader is None)

12
Lib/importlib/test/builtin/test_loader.py
View file

@ -18,10 +18,10 @@ class LoaderTests(abc.LoaderTests):
def verify(self, module): def verify(self, module):
"""Verify that the module matches against what it should have.""" """Verify that the module matches against what it should have."""
self.assert_(isinstance(module, types.ModuleType)) self.assertTrue(isinstance(module, types.ModuleType))
for attr, value in self.verification.items(): for attr, value in self.verification.items():
self.assertEqual(getattr(module, attr), value) self.assertEqual(getattr(module, attr), value)
self.assert_(module.__name__ in sys.modules) self.assertTrue(module.__name__ in sys.modules)
load_module = staticmethod(lambda name: load_module = staticmethod(lambda name:
machinery.BuiltinImporter.load_module(name)) machinery.BuiltinImporter.load_module(name))
@ -49,7 +49,7 @@ def test_module_reuse(self):
with util.uncache(builtin_util.NAME): with util.uncache(builtin_util.NAME):
module1 = self.load_module(builtin_util.NAME) module1 = self.load_module(builtin_util.NAME)
module2 = self.load_module(builtin_util.NAME) module2 = self.load_module(builtin_util.NAME)
self.assert_(module1 is module2) self.assertTrue(module1 is module2)
def test_unloadable(self): def test_unloadable(self):
name = 'dssdsdfff' name = 'dssdsdfff'
@ -70,17 +70,17 @@ class InspectLoaderTests(unittest.TestCase):
def test_get_code(self): def test_get_code(self):
# There is no code object. # There is no code object.
result = machinery.BuiltinImporter.get_code(builtin_util.NAME) result = machinery.BuiltinImporter.get_code(builtin_util.NAME)
self.assert_(result is None) self.assertTrue(result is None)
def test_get_source(self): def test_get_source(self):
# There is no source. # There is no source.
result = machinery.BuiltinImporter.get_source(builtin_util.NAME) result = machinery.BuiltinImporter.get_source(builtin_util.NAME)
self.assert_(result is None) self.assertTrue(result is None)
def test_is_package(self): def test_is_package(self):
# Cannot be a package. # Cannot be a package.
result = machinery.BuiltinImporter.is_package(builtin_util.NAME) result = machinery.BuiltinImporter.is_package(builtin_util.NAME)
self.assert_(not result) self.assertTrue(not result)
def test_not_builtin(self): def test_not_builtin(self):
# Modules not built-in should raise ImportError. # Modules not built-in should raise ImportError.

4
Lib/importlib/test/extension/test_finder.py
View file

@ -13,7 +13,7 @@ def find_module(self, fullname):
return importer.find_module(fullname) return importer.find_module(fullname)
def test_module(self): def test_module(self):
self.assert_(self.find_module(util.NAME)) self.assertTrue(self.find_module(util.NAME))
def test_package(self): def test_package(self):
# Extension modules cannot be an __init__ for a package. # Extension modules cannot be an __init__ for a package.
@ -32,7 +32,7 @@ def test_package_over_module(self):
pass pass
def test_failure(self): def test_failure(self):
self.assert_(self.find_module('asdfjkl;') is None) self.assertTrue(self.find_module('asdfjkl;') is None)
# XXX Raise an exception if someone tries to use the 'path' argument? # XXX Raise an exception if someone tries to use the 'path' argument?

6
Lib/importlib/test/extension/test_loader.py
View file

@ -23,8 +23,8 @@ def test_module(self):
('__file__', ext_util.FILEPATH), ('__file__', ext_util.FILEPATH),
('__package__', '')]: ('__package__', '')]:
self.assertEqual(getattr(module, attr), value) self.assertEqual(getattr(module, attr), value)
self.assert_(ext_util.NAME in sys.modules) self.assertTrue(ext_util.NAME in sys.modules)
self.assert_(isinstance(module.__loader__, self.assertTrue(isinstance(module.__loader__,
_bootstrap._ExtensionFileLoader)) _bootstrap._ExtensionFileLoader))
def test_package(self): def test_package(self):
@ -39,7 +39,7 @@ def test_module_reuse(self):
with util.uncache(ext_util.NAME): with util.uncache(ext_util.NAME):
module1 = self.load_module(ext_util.NAME) module1 = self.load_module(ext_util.NAME)
module2 = self.load_module(ext_util.NAME) module2 = self.load_module(ext_util.NAME)
self.assert_(module1 is module2) self.assertTrue(module1 is module2)
def test_state_after_failure(self): def test_state_after_failure(self):
# No easy way to trigger a failure after a successful import. # No easy way to trigger a failure after a successful import.

2
Lib/importlib/test/extension/test_path_hook.py
View file

@ -19,7 +19,7 @@ def hook(self, entry):
def test_success(self): def test_success(self):
# Path hook should handle a directory where a known extension module # Path hook should handle a directory where a known extension module
# exists. # exists.
self.assert_(hasattr(self.hook(util.PATH), 'find_module')) self.assertTrue(hasattr(self.hook(util.PATH), 'find_module'))
def test_main(): def test_main():

8
Lib/importlib/test/frozen/test_finder.py
View file

@ -15,15 +15,15 @@ def find(self, name, path=None):
def test_module(self): def test_module(self):
name = '__hello__' name = '__hello__'
loader = self.find(name) loader = self.find(name)
self.assert_(hasattr(loader, 'load_module')) self.assertTrue(hasattr(loader, 'load_module'))
def test_package(self): def test_package(self):
loader = self.find('__phello__') loader = self.find('__phello__')
self.assert_(hasattr(loader, 'load_module')) self.assertTrue(hasattr(loader, 'load_module'))
def test_module_in_package(self): def test_module_in_package(self):
loader = self.find('__phello__.spam', ['__phello__']) loader = self.find('__phello__.spam', ['__phello__'])
self.assert_(hasattr(loader, 'load_module')) self.assertTrue(hasattr(loader, 'load_module'))
def test_package_in_package(self): def test_package_in_package(self):
# No frozen package within another package to test with. # No frozen package within another package to test with.
@ -35,7 +35,7 @@ def test_package_over_module(self):
def test_failure(self): def test_failure(self):
loader = self.find('<not real>') loader = self.find('<not real>')
self.assert_(loader is None) self.assertTrue(loader is None)
def test_main(): def test_main():

8
Lib/importlib/test/frozen/test_loader.py
View file

@ -43,7 +43,7 @@ def test_module_reuse(self):
with util.uncache('__hello__'): with util.uncache('__hello__'):
module1 = machinery.FrozenImporter.load_module('__hello__') module1 = machinery.FrozenImporter.load_module('__hello__')
module2 = machinery.FrozenImporter.load_module('__hello__') module2 = machinery.FrozenImporter.load_module('__hello__')
self.assert_(module1 is module2) self.assertTrue(module1 is module2)
def test_state_after_failure(self): def test_state_after_failure(self):
# No way to trigger an error in a frozen module. # No way to trigger an error in a frozen module.
@ -65,12 +65,12 @@ def test_get_code(self):
code = machinery.FrozenImporter.get_code(name) code = machinery.FrozenImporter.get_code(name)
mod = imp.new_module(name) mod = imp.new_module(name)
exec(code, mod.__dict__) exec(code, mod.__dict__)
self.assert_(hasattr(mod, 'initialized')) self.assertTrue(hasattr(mod, 'initialized'))
def test_get_source(self): def test_get_source(self):
# Should always return None. # Should always return None.
result = machinery.FrozenImporter.get_source('__hello__') result = machinery.FrozenImporter.get_source('__hello__')
self.assert_(result is None) self.assertTrue(result is None)
def test_is_package(self): def test_is_package(self):
# Should be able to tell what is a package. # Should be able to tell what is a package.
@ -78,7 +78,7 @@ def test_is_package(self):
('__phello__.spam', False)) ('__phello__.spam', False))
for name, is_package in test_for: for name, is_package in test_for:
result = machinery.FrozenImporter.is_package(name) result = machinery.FrozenImporter.is_package(name)
self.assert_(bool(result) == is_package) self.assertTrue(bool(result) == is_package)
def test_failure(self): def test_failure(self):
# Raise ImportError for modules that are not frozen. # Raise ImportError for modules that are not frozen.

6
Lib/importlib/test/import_/test_caching.py
View file

@ -53,8 +53,8 @@ def test_using_cache_for_assigning_to_attribute(self):
with self.create_mock('pkg.__init__', 'pkg.module') as importer: with self.create_mock('pkg.__init__', 'pkg.module') as importer:
with util.import_state(meta_path=[importer]): with util.import_state(meta_path=[importer]):
module = import_util.import_('pkg.module') module = import_util.import_('pkg.module')
self.assert_(hasattr(module, 'module')) self.assertTrue(hasattr(module, 'module'))
self.assert_(id(module.module), id(sys.modules['pkg.module'])) self.assertTrue(id(module.module), id(sys.modules['pkg.module']))
# See test_using_cache_after_loader() for reasoning. # See test_using_cache_after_loader() for reasoning.
@import_util.importlib_only @import_util.importlib_only
@ -63,7 +63,7 @@ def test_using_cache_for_fromlist(self):
with self.create_mock('pkg.__init__', 'pkg.module') as importer: with self.create_mock('pkg.__init__', 'pkg.module') as importer:
with util.import_state(meta_path=[importer]): with util.import_state(meta_path=[importer]):
module = import_util.import_('pkg', fromlist=['module']) module = import_util.import_('pkg', fromlist=['module'])
self.assert_(hasattr(module, 'module')) self.assertTrue(hasattr(module, 'module'))
self.assertEquals(id(module.module), self.assertEquals(id(module.module),
id(sys.modules['pkg.module'])) id(sys.modules['pkg.module']))

12
Lib/importlib/test/import_/test_fromlist.py
View file

@ -59,7 +59,7 @@ def test_unexistent_object(self):
with util.import_state(meta_path=[importer]): with util.import_state(meta_path=[importer]):
module = import_util.import_('module', fromlist=['non_existent']) module = import_util.import_('module', fromlist=['non_existent'])
self.assertEquals(module.__name__, 'module') self.assertEquals(module.__name__, 'module')
self.assert_(not hasattr(module, 'non_existent')) self.assertTrue(not hasattr(module, 'non_existent'))
def test_module_from_package(self): def test_module_from_package(self):
# [module] # [module]
@ -67,7 +67,7 @@ def test_module_from_package(self):
with util.import_state(meta_path=[importer]): with util.import_state(meta_path=[importer]):
module = import_util.import_('pkg', fromlist=['module']) module = import_util.import_('pkg', fromlist=['module'])
self.assertEquals(module.__name__, 'pkg') self.assertEquals(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module')) self.assertTrue(hasattr(module, 'module'))
self.assertEquals(module.module.__name__, 'pkg.module') self.assertEquals(module.module.__name__, 'pkg.module')
def test_no_module_from_package(self): def test_no_module_from_package(self):
@ -76,7 +76,7 @@ def test_no_module_from_package(self):
with util.import_state(meta_path=[importer]): with util.import_state(meta_path=[importer]):
module = import_util.import_('pkg', fromlist='non_existent') module = import_util.import_('pkg', fromlist='non_existent')
self.assertEquals(module.__name__, 'pkg') self.assertEquals(module.__name__, 'pkg')
self.assert_(not hasattr(module, 'non_existent')) self.assertTrue(not hasattr(module, 'non_existent'))
def test_empty_string(self): def test_empty_string(self):
with util.mock_modules('pkg.__init__', 'pkg.mod') as importer: with util.mock_modules('pkg.__init__', 'pkg.mod') as importer:
@ -91,7 +91,7 @@ def test_using_star(self):
mock['pkg'].__all__ = ['module'] mock['pkg'].__all__ = ['module']
module = import_util.import_('pkg', fromlist=['*']) module = import_util.import_('pkg', fromlist=['*'])
self.assertEquals(module.__name__, 'pkg') self.assertEquals(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module')) self.assertTrue(hasattr(module, 'module'))
self.assertEqual(module.module.__name__, 'pkg.module') self.assertEqual(module.module.__name__, 'pkg.module')
def test_star_with_others(self): def test_star_with_others(self):
@ -102,8 +102,8 @@ def test_star_with_others(self):
mock['pkg'].__all__ = ['module1'] mock['pkg'].__all__ = ['module1']
module = import_util.import_('pkg', fromlist=['module2', '*']) module = import_util.import_('pkg', fromlist=['module2', '*'])
self.assertEquals(module.__name__, 'pkg') self.assertEquals(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module1')) self.assertTrue(hasattr(module, 'module1'))
self.assert_(hasattr(module, 'module2')) self.assertTrue(hasattr(module, 'module2'))
self.assertEquals(module.module1.__name__, 'pkg.module1') self.assertEquals(module.module1.__name__, 'pkg.module1')
self.assertEquals(module.module2.__name__, 'pkg.module2') self.assertEquals(module.module2.__name__, 'pkg.module2')

6
Lib/importlib/test/import_/test_meta_path.py
View file

@ -64,7 +64,7 @@ def test_no_path(self):
self.assertEquals(len(args), 2) self.assertEquals(len(args), 2)
self.assertEquals(len(kwargs), 0) self.assertEquals(len(kwargs), 0)
self.assertEquals(args[0], mod_name) self.assertEquals(args[0], mod_name)
self.assert_(args[1] is None) self.assertTrue(args[1] is None)
def test_with_path(self): def test_with_path(self):
# [path set] # [path set]
@ -82,9 +82,9 @@ def test_with_path(self):
args = log[1][0] args = log[1][0]
kwargs = log[1][1] kwargs = log[1][1]
# Assuming all arguments are positional. # Assuming all arguments are positional.
self.assert_(not kwargs) self.assertTrue(not kwargs)
self.assertEquals(args[0], mod_name) self.assertEquals(args[0], mod_name)
self.assert_(args[1] is path) self.assertTrue(args[1] is path)

2
Lib/importlib/test/import_/test_packages.py
View file

@ -13,7 +13,7 @@ def test_import_parent(self):
with util.mock_modules('pkg.__init__', 'pkg.module') as mock: with util.mock_modules('pkg.__init__', 'pkg.module') as mock:
with util.import_state(meta_path=[mock]): with util.import_state(meta_path=[mock]):
module = import_util.import_('pkg.module') module = import_util.import_('pkg.module')
self.assert_('pkg' in sys.modules) self.assertTrue('pkg' in sys.modules)
def test_bad_parent(self): def test_bad_parent(self):
with util.mock_modules('pkg.module') as mock: with util.mock_modules('pkg.module') as mock:

30
Lib/importlib/test/import_/test_path.py
View file

@ -19,7 +19,7 @@ def test_failure(self):
# Test None returned upon not finding a suitable finder. # Test None returned upon not finding a suitable finder.
module = '<test module>' module = '<test module>'
with util.import_state(): with util.import_state():
self.assert_(machinery.PathFinder.find_module(module) is None) self.assertTrue(machinery.PathFinder.find_module(module) is None)
def test_sys_path(self): def test_sys_path(self):
# Test that sys.path is used when 'path' is None. # Test that sys.path is used when 'path' is None.
@ -30,7 +30,7 @@ def test_sys_path(self):
with util.import_state(path_importer_cache={path: importer}, with util.import_state(path_importer_cache={path: importer},
path=[path]): path=[path]):
loader = machinery.PathFinder.find_module(module) loader = machinery.PathFinder.find_module(module)
self.assert_(loader is importer) self.assertTrue(loader is importer)
def test_path(self): def test_path(self):
# Test that 'path' is used when set. # Test that 'path' is used when set.
@ -40,7 +40,7 @@ def test_path(self):
importer = util.mock_modules(module) importer = util.mock_modules(module)
with util.import_state(path_importer_cache={path: importer}): with util.import_state(path_importer_cache={path: importer}):
loader = machinery.PathFinder.find_module(module, [path]) loader = machinery.PathFinder.find_module(module, [path])
self.assert_(loader is importer) self.assertTrue(loader is importer)
def test_path_hooks(self): def test_path_hooks(self):
# Test that sys.path_hooks is used. # Test that sys.path_hooks is used.
@ -51,16 +51,16 @@ def test_path_hooks(self):
hook = import_util.mock_path_hook(path, importer=importer) hook = import_util.mock_path_hook(path, importer=importer)
with util.import_state(path_hooks=[hook]): with util.import_state(path_hooks=[hook]):
loader = machinery.PathFinder.find_module(module, [path]) loader = machinery.PathFinder.find_module(module, [path])
self.assert_(loader is importer) self.assertTrue(loader is importer)
self.assert_(path in sys.path_importer_cache) self.assertTrue(path in sys.path_importer_cache)
self.assert_(sys.path_importer_cache[path] is importer) self.assertTrue(sys.path_importer_cache[path] is importer)
def test_path_importer_cache_has_None(self): def test_path_importer_cache_has_None(self):
# Test that if sys.path_importer_cache has None that None is returned. # Test that if sys.path_importer_cache has None that None is returned.
clear_cache = {path: None for path in sys.path} clear_cache = {path: None for path in sys.path}
with util.import_state(path_importer_cache=clear_cache): with util.import_state(path_importer_cache=clear_cache):
for name in ('asynchat', 'sys', '<test module>'): for name in ('asynchat', 'sys', '<test module>'):
self.assert_(machinery.PathFinder.find_module(name) is None) self.assertTrue(machinery.PathFinder.find_module(name) is None)
def test_path_importer_cache_has_None_continues(self): def test_path_importer_cache_has_None_continues(self):
# Test that having None in sys.path_importer_cache causes the search to # Test that having None in sys.path_importer_cache causes the search to
@ -71,7 +71,7 @@ def test_path_importer_cache_has_None_continues(self):
with util.import_state(path=['1', '2'], with util.import_state(path=['1', '2'],
path_importer_cache={'1': None, '2': importer}): path_importer_cache={'1': None, '2': importer}):
loader = machinery.PathFinder.find_module(module) loader = machinery.PathFinder.find_module(module)
self.assert_(loader is importer) self.assertTrue(loader is importer)
@ -88,15 +88,15 @@ def test_implicit_hooks(self):
with util.import_state(): with util.import_state():
nothing = _bootstrap._DefaultPathFinder.find_module(module, nothing = _bootstrap._DefaultPathFinder.find_module(module,
path=[existing_path]) path=[existing_path])
self.assert_(nothing is None) self.assertTrue(nothing is None)
self.assert_(existing_path in sys.path_importer_cache) self.assertTrue(existing_path in sys.path_importer_cache)
self.assert_(not isinstance(sys.path_importer_cache[existing_path], self.assertTrue(not isinstance(sys.path_importer_cache[existing_path],
imp.NullImporter)) imp.NullImporter))
nothing = _bootstrap._DefaultPathFinder.find_module(module, nothing = _bootstrap._DefaultPathFinder.find_module(module,
path=[bad_path]) path=[bad_path])
self.assert_(nothing is None) self.assertTrue(nothing is None)
self.assert_(bad_path in sys.path_importer_cache) self.assertTrue(bad_path in sys.path_importer_cache)
self.assert_(isinstance(sys.path_importer_cache[bad_path], self.assertTrue(isinstance(sys.path_importer_cache[bad_path],
imp.NullImporter)) imp.NullImporter))
def test_path_importer_cache_has_None(self): def test_path_importer_cache_has_None(self):
@ -113,7 +113,7 @@ def test_path_importer_cache_has_None(self):
with util.import_state(path_importer_cache={path: None}): with util.import_state(path_importer_cache={path: None}):
loader = _bootstrap._DefaultPathFinder.find_module(module, loader = _bootstrap._DefaultPathFinder.find_module(module,
path=[path]) path=[path])
self.assert_(loader is importer) self.assertTrue(loader is importer)
finally: finally:
_bootstrap._DEFAULT_PATH_HOOK = original_hook _bootstrap._DEFAULT_PATH_HOOK = original_hook

6
Lib/importlib/test/import_/test_relative_imports.py
View file

@ -79,7 +79,7 @@ def callback(global_):
import_util.import_('pkg') # For __import__(). import_util.import_('pkg') # For __import__().
module = import_util.import_('', global_, fromlist=['mod2'], level=1) module = import_util.import_('', global_, fromlist=['mod2'], level=1)
self.assertEqual(module.__name__, 'pkg') self.assertEqual(module.__name__, 'pkg')
self.assert_(hasattr(module, 'mod2')) self.assertTrue(hasattr(module, 'mod2'))
self.assertEqual(module.mod2.attr, 'pkg.mod2') self.assertEqual(module.mod2.attr, 'pkg.mod2')
self.relative_import_test(create, globals_, callback) self.relative_import_test(create, globals_, callback)
@ -105,7 +105,7 @@ def callback(global_):
module = import_util.import_('', global_, fromlist=['module'], module = import_util.import_('', global_, fromlist=['module'],
level=1) level=1)
self.assertEqual(module.__name__, 'pkg') self.assertEqual(module.__name__, 'pkg')
self.assert_(hasattr(module, 'module')) self.assertTrue(hasattr(module, 'module'))
self.assertEqual(module.module.attr, 'pkg.module') self.assertEqual(module.module.attr, 'pkg.module')
self.relative_import_test(create, globals_, callback) self.relative_import_test(create, globals_, callback)
@ -129,7 +129,7 @@ def callback(global_):
module = import_util.import_('', global_, fromlist=['subpkg2'], module = import_util.import_('', global_, fromlist=['subpkg2'],
level=2) level=2)
self.assertEqual(module.__name__, 'pkg') self.assertEqual(module.__name__, 'pkg')
self.assert_(hasattr(module, 'subpkg2')) self.assertTrue(hasattr(module, 'subpkg2'))
self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__') self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__')
def test_deep_import(self): def test_deep_import(self):

22
Lib/importlib/test/source/test_abc_loader.py
View file

@ -133,10 +133,10 @@ def test_module(self):
mock = self.mocker({name: path}) mock = self.mocker({name: path})
with util.uncache(name): with util.uncache(name):
module = mock.load_module(name) module = mock.load_module(name)
self.assert_(name in sys.modules) self.assertTrue(name in sys.modules)
self.eq_attrs(module, __name__=name, __file__=path, __package__='', self.eq_attrs(module, __name__=name, __file__=path, __package__='',
__loader__=mock) __loader__=mock)
self.assert_(not hasattr(module, '__path__')) self.assertTrue(not hasattr(module, '__path__'))
return mock, name return mock, name
def test_package(self): def test_package(self):
@ -145,7 +145,7 @@ def test_package(self):
mock = self.mocker({name: path}) mock = self.mocker({name: path})
with util.uncache(name): with util.uncache(name):
module = mock.load_module(name) module = mock.load_module(name)
self.assert_(name in sys.modules) self.assertTrue(name in sys.modules)
self.eq_attrs(module, __name__=name, __file__=path, self.eq_attrs(module, __name__=name, __file__=path,
__path__=[os.path.dirname(path)], __package__=name, __path__=[os.path.dirname(path)], __package__=name,
__loader__=mock) __loader__=mock)
@ -171,8 +171,8 @@ def test_module_reuse(self):
with util.uncache(name): with util.uncache(name):
sys.modules[name] = module sys.modules[name] = module
loaded_module = mock.load_module(name) loaded_module = mock.load_module(name)
self.assert_(loaded_module is module) self.assertTrue(loaded_module is module)
self.assert_(sys.modules[name] is module) self.assertTrue(sys.modules[name] is module)
return mock, name return mock, name
def test_state_after_failure(self): def test_state_after_failure(self):
@ -184,8 +184,8 @@ def test_state_after_failure(self):
with util.uncache(name): with util.uncache(name):
sys.modules[name] = module sys.modules[name] = module
self.assertRaises(ZeroDivisionError, mock.load_module, name) self.assertRaises(ZeroDivisionError, mock.load_module, name)
self.assert_(sys.modules[name] is module) self.assertTrue(sys.modules[name] is module)
self.assert_(hasattr(module, 'blah')) self.assertTrue(hasattr(module, 'blah'))
return mock return mock
def test_unloadable(self): def test_unloadable(self):
@ -194,7 +194,7 @@ def test_unloadable(self):
mock.source = b"1/0" mock.source = b"1/0"
with util.uncache(name): with util.uncache(name):
self.assertRaises(ZeroDivisionError, mock.load_module, name) self.assertRaises(ZeroDivisionError, mock.load_module, name)
self.assert_(name not in sys.modules) self.assertTrue(name not in sys.modules)
return mock return mock
@ -293,7 +293,7 @@ def run_test(self, dont_write_bytecode):
sys.dont_write_bytecode = dont_write_bytecode sys.dont_write_bytecode = dont_write_bytecode
with util.uncache(name): with util.uncache(name):
mock.load_module(name) mock.load_module(name)
self.assert_((name in mock.module_bytecode) is not self.assertTrue((name in mock.module_bytecode) is not
dont_write_bytecode) dont_write_bytecode)
def test_no_bytecode_written(self): def test_no_bytecode_written(self):
@ -319,7 +319,7 @@ def test_different_magic(self):
'magic': bad_magic}}) 'magic': bad_magic}})
with util.uncache(name): with util.uncache(name):
mock.load_module(name) mock.load_module(name)
self.assert_(name in mock.module_bytecode) self.assertTrue(name in mock.module_bytecode)
magic = mock.module_bytecode[name][:4] magic = mock.module_bytecode[name][:4]
self.assertEqual(magic, imp.get_magic()) self.assertEqual(magic, imp.get_magic())
@ -332,7 +332,7 @@ def test_old_mtime(self):
{name: {'path': 'path/to/mod.bytecode', 'mtime': old_mtime}}) {name: {'path': 'path/to/mod.bytecode', 'mtime': old_mtime}})
with util.uncache(name): with util.uncache(name):
mock.load_module(name) mock.load_module(name)
self.assert_(name in mock.module_bytecode) self.assertTrue(name in mock.module_bytecode)
mtime = importlib._r_long(mock.module_bytecode[name][4:8]) mtime = importlib._r_long(mock.module_bytecode[name][4:8])
self.assertEqual(mtime, PyPycLoaderMock.default_mtime) self.assertEqual(mtime, PyPycLoaderMock.default_mtime)

14
Lib/importlib/test/source/test_file_loader.py
View file

@ -23,7 +23,7 @@ def test_module(self):
loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'], loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'],
False) False)
module = loader.load_module('_temp') module = loader.load_module('_temp')
self.assert_('_temp' in sys.modules) self.assertTrue('_temp' in sys.modules)
check = {'__name__': '_temp', '__file__': mapping['_temp'], check = {'__name__': '_temp', '__file__': mapping['_temp'],
'__package__': ''} '__package__': ''}
for attr, value in check.items(): for attr, value in check.items():
@ -35,7 +35,7 @@ def test_package(self):
mapping['_pkg.__init__'], mapping['_pkg.__init__'],
True) True)
module = loader.load_module('_pkg') module = loader.load_module('_pkg')
self.assert_('_pkg' in sys.modules) self.assertTrue('_pkg' in sys.modules)
check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'], check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'],
'__path__': [os.path.dirname(mapping['_pkg.__init__'])], '__path__': [os.path.dirname(mapping['_pkg.__init__'])],
'__package__': '_pkg'} '__package__': '_pkg'}
@ -48,7 +48,7 @@ def test_lacking_parent(self):
loader = _bootstrap._PyPycFileLoader('_pkg.mod', loader = _bootstrap._PyPycFileLoader('_pkg.mod',
mapping['_pkg.mod'], False) mapping['_pkg.mod'], False)
module = loader.load_module('_pkg.mod') module = loader.load_module('_pkg.mod')
self.assert_('_pkg.mod' in sys.modules) self.assertTrue('_pkg.mod' in sys.modules)
check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'], check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'],
'__package__': '_pkg'} '__package__': '_pkg'}
for attr, value in check.items(): for attr, value in check.items():
@ -73,7 +73,7 @@ def test_module_reuse(self):
# than the original mtime. # than the original mtime.
loader.source_mtime = self.fake_mtime(loader.source_mtime) loader.source_mtime = self.fake_mtime(loader.source_mtime)
module = loader.load_module('_temp') module = loader.load_module('_temp')
self.assert_('testing_var' in module.__dict__, self.assertTrue('testing_var' in module.__dict__,
"'testing_var' not in " "'testing_var' not in "
"{0}".format(list(module.__dict__.keys()))) "{0}".format(list(module.__dict__.keys())))
self.assertEqual(module, sys.modules['_temp']) self.assertEqual(module, sys.modules['_temp'])
@ -105,7 +105,7 @@ def test_bad_syntax(self):
loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'], loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'],
False) False)
self.assertRaises(SyntaxError, loader.load_module, '_temp') self.assertRaises(SyntaxError, loader.load_module, '_temp')
self.assert_('_temp' not in sys.modules) self.assertTrue('_temp' not in sys.modules)
class BadBytecodeTest(unittest.TestCase): class BadBytecodeTest(unittest.TestCase):
@ -124,7 +124,7 @@ class BadBytecodeTest(unittest.TestCase):
def import_(self, file, module_name): def import_(self, file, module_name):
loader = _bootstrap._PyPycFileLoader(module_name, file, False) loader = _bootstrap._PyPycFileLoader(module_name, file, False)
module = loader.load_module(module_name) module = loader.load_module(module_name)
self.assert_(module_name in sys.modules) self.assertTrue(module_name in sys.modules)
# [bad magic] # [bad magic]
@source_util.writes_bytecode_files @source_util.writes_bytecode_files
@ -168,7 +168,7 @@ def test_bad_marshal(self):
bytecode_file.write(b'AAAA') bytecode_file.write(b'AAAA')
self.assertRaises(ValueError, self.import_, mapping['_temp'], self.assertRaises(ValueError, self.import_, mapping['_temp'],
'_temp') '_temp')
self.assert_('_temp' not in sys.modules) self.assertTrue('_temp' not in sys.modules)
def test_main(): def test_main():

10
Lib/importlib/test/source/test_finder.py
View file

@ -53,7 +53,7 @@ def run_test(self, test, create=None, *, compile_=None, unlink=None):
for name in unlink: for name in unlink:
os.unlink(mapping[name]) os.unlink(mapping[name])
loader = self.import_(mapping['.root'], test) loader = self.import_(mapping['.root'], test)
self.assert_(hasattr(loader, 'load_module')) self.assertTrue(hasattr(loader, 'load_module'))
return loader return loader
def test_module(self): def test_module(self):
@ -79,7 +79,7 @@ def test_module_in_package(self):
with source_util.create_modules('pkg.__init__', 'pkg.sub') as mapping: with source_util.create_modules('pkg.__init__', 'pkg.sub') as mapping:
pkg_dir = os.path.dirname(mapping['pkg.__init__']) pkg_dir = os.path.dirname(mapping['pkg.__init__'])
loader = self.import_(pkg_dir, 'pkg.sub') loader = self.import_(pkg_dir, 'pkg.sub')
self.assert_(hasattr(loader, 'load_module')) self.assertTrue(hasattr(loader, 'load_module'))
# [sub package] # [sub package]
def test_package_in_package(self): def test_package_in_package(self):
@ -87,7 +87,7 @@ def test_package_in_package(self):
with context as mapping: with context as mapping:
pkg_dir = os.path.dirname(mapping['pkg.__init__']) pkg_dir = os.path.dirname(mapping['pkg.__init__'])
loader = self.import_(pkg_dir, 'pkg.sub') loader = self.import_(pkg_dir, 'pkg.sub')
self.assert_(hasattr(loader, 'load_module')) self.assertTrue(hasattr(loader, 'load_module'))
# [sub empty] # [sub empty]
def test_empty_sub_directory(self): def test_empty_sub_directory(self):
@ -105,13 +105,13 @@ def test_package_over_module(self):
# XXX This is not a blackbox test! # XXX This is not a blackbox test!
name = '_temp' name = '_temp'
loader = self.run_test(name, {'{0}.__init__'.format(name), name}) loader = self.run_test(name, {'{0}.__init__'.format(name), name})
self.assert_('__init__' in loader._base_path) self.assertTrue('__init__' in loader._base_path)
def test_failure(self): def test_failure(self):
with source_util.create_modules('blah') as mapping: with source_util.create_modules('blah') as mapping:
nothing = self.import_(mapping['.root'], 'sdfsadsadf') nothing = self.import_(mapping['.root'], 'sdfsadsadf')
self.assert_(nothing is None) self.assertTrue(nothing is None)
# [empty dir] # [empty dir]
def test_empty_dir(self): def test_empty_dir(self):

2
Lib/importlib/test/source/test_path_hook.py
View file

@ -10,7 +10,7 @@ class PathHookTest(unittest.TestCase):
def test_success(self): def test_success(self):
# XXX Only work on existing directories? # XXX Only work on existing directories?
with source_util.create_modules('dummy') as mapping: with source_util.create_modules('dummy') as mapping:
self.assert_(hasattr(_bootstrap._FileFinder(mapping['.root']), self.assertTrue(hasattr(_bootstrap._FileFinder(mapping['.root']),
'find_module')) 'find_module'))

2
Lib/importlib/test/test_abc.py
View file

@ -11,7 +11,7 @@ class SubclassTests(unittest.TestCase):
def verify(self, ABC, *classes): def verify(self, ABC, *classes):
"""Verify the classes are subclasses of the ABC.""" """Verify the classes are subclasses of the ABC."""
for cls in classes: for cls in classes:
self.assert_(issubclass(cls, ABC)) self.assertTrue(issubclass(cls, ABC))
def test_Finder(self): def test_Finder(self):
self.verify(abc.Finder, machinery.BuiltinImporter, self.verify(abc.Finder, machinery.BuiltinImporter,

12
Lib/importlib/test/test_util.py
View file

@ -29,8 +29,8 @@ def test_new_module(self):
module_name = 'a.b.c' module_name = 'a.b.c'
with test_util.uncache(module_name): with test_util.uncache(module_name):
module = self.return_module(module_name) module = self.return_module(module_name)
self.assert_(module_name in sys.modules) self.assertTrue(module_name in sys.modules)
self.assert_(isinstance(module, types.ModuleType)) self.assertTrue(isinstance(module, types.ModuleType))
self.assertEqual(module.__name__, module_name) self.assertEqual(module.__name__, module_name)
def test_reload(self): def test_reload(self):
@ -40,7 +40,7 @@ def test_reload(self):
with test_util.uncache(name): with test_util.uncache(name):
sys.modules[name] = module sys.modules[name] = module
returned_module = self.return_module(name) returned_module = self.return_module(name)
self.assert_(sys.modules[name] is returned_module) self.assertTrue(sys.modules[name] is returned_module)
def test_new_module_failure(self): def test_new_module_failure(self):
# Test that a module is removed from sys.modules if added but an # Test that a module is removed from sys.modules if added but an
@ -48,7 +48,7 @@ def test_new_module_failure(self):
name = 'a.b.c' name = 'a.b.c'
with test_util.uncache(name): with test_util.uncache(name):
self.raise_exception(name) self.raise_exception(name)
self.assert_(name not in sys.modules) self.assertTrue(name not in sys.modules)
def test_reload_failure(self): def test_reload_failure(self):
# Test that a failure on reload leaves the module in-place. # Test that a failure on reload leaves the module in-place.
@ -57,7 +57,7 @@ def test_reload_failure(self):
with test_util.uncache(name): with test_util.uncache(name):
sys.modules[name] = module sys.modules[name] = module
self.raise_exception(name) self.raise_exception(name)
self.assert_(sys.modules[name] is module) self.assertTrue(sys.modules[name] is module)
class SetPackageTests(unittest.TestCase): class SetPackageTests(unittest.TestCase):
@ -71,7 +71,7 @@ def verify(self, module, expect):
fxn = lambda: module fxn = lambda: module
wrapped = util.set_package(fxn) wrapped = util.set_package(fxn)
wrapped() wrapped()
self.assert_(hasattr(module, '__package__')) self.assertTrue(hasattr(module, '__package__'))
self.assertEqual(expect, module.__package__) self.assertEqual(expect, module.__package__)
def test_top_level(self): def test_top_level(self):

4
Lib/json/tests/test_decode.py
View file

@ -8,12 +8,12 @@
class TestDecode(TestCase): class TestDecode(TestCase):
def test_decimal(self): def test_decimal(self):
rval = json.loads('1.1', parse_float=decimal.Decimal) rval = json.loads('1.1', parse_float=decimal.Decimal)
self.assert_(isinstance(rval, decimal.Decimal)) self.assertTrue(isinstance(rval, decimal.Decimal))
self.assertEquals(rval, decimal.Decimal('1.1')) self.assertEquals(rval, decimal.Decimal('1.1'))
def test_float(self): def test_float(self):
rval = json.loads('1', parse_int=float) rval = json.loads('1', parse_int=float)
self.assert_(isinstance(rval, float)) self.assertTrue(isinstance(rval, float))
self.assertEquals(rval, 1.0) self.assertEquals(rval, 1.0)
def test_object_pairs_hook(self): def test_object_pairs_hook(self):

4
Lib/json/tests/test_speedups.py
View file

@ -7,9 +7,9 @@
class TestSpeedups(TestCase): class TestSpeedups(TestCase):
def test_scanstring(self): def test_scanstring(self):
self.assertEquals(decoder.scanstring.__module__, "_json") self.assertEquals(decoder.scanstring.__module__, "_json")
self.assert_(decoder.scanstring is decoder.c_scanstring) self.assertTrue(decoder.scanstring is decoder.c_scanstring)
def test_encode_basestring_ascii(self): def test_encode_basestring_ascii(self):
self.assertEquals(encoder.encode_basestring_ascii.__module__, "_json") self.assertEquals(encoder.encode_basestring_ascii.__module__, "_json")
self.assert_(encoder.encode_basestring_ascii is self.assertTrue(encoder.encode_basestring_ascii is
encoder.c_encode_basestring_ascii) encoder.c_encode_basestring_ascii)

92
Lib/test/mapping_tests.py
View file

@ -50,15 +50,15 @@ def test_read(self):
for key, value in self.reference.items(): for key, value in self.reference.items():
self.assertEqual(d[key], value) self.assertEqual(d[key], value)
knownkey = list(self.other.keys())[0] knownkey = list(self.other.keys())[0]
self.failUnlessRaises(KeyError, lambda:d[knownkey]) self.assertRaises(KeyError, lambda:d[knownkey])
#len #len
self.assertEqual(len(p), 0) self.assertEqual(len(p), 0)
self.assertEqual(len(d), len(self.reference)) self.assertEqual(len(d), len(self.reference))
#__contains__ #__contains__
for k in self.reference: for k in self.reference:
self.assert_(k in d) self.assertTrue(k in d)
for k in self.other: for k in self.other:
self.failIf(k in d) self.assertFalse(k in d)
#cmp #cmp
self.assertEqual(p, p) self.assertEqual(p, p)
self.assertEqual(d, d) self.assertEqual(d, d)
@ -69,10 +69,10 @@ def test_read(self):
if not d: self.fail("Full mapping must compare to True") if not d: self.fail("Full mapping must compare to True")
# keys(), items(), iterkeys() ... # keys(), items(), iterkeys() ...
def check_iterandlist(iter, lst, ref): def check_iterandlist(iter, lst, ref):
self.assert_(hasattr(iter, '__next__')) self.assertTrue(hasattr(iter, '__next__'))
self.assert_(hasattr(iter, '__iter__')) self.assertTrue(hasattr(iter, '__iter__'))
x = list(iter) x = list(iter)
self.assert_(set(x)==set(lst)==set(ref)) self.assertTrue(set(x)==set(lst)==set(ref))
check_iterandlist(iter(d.keys()), list(d.keys()), check_iterandlist(iter(d.keys()), list(d.keys()),
self.reference.keys()) self.reference.keys())
check_iterandlist(iter(d), list(d.keys()), self.reference.keys()) check_iterandlist(iter(d), list(d.keys()), self.reference.keys())
@ -85,7 +85,7 @@ def check_iterandlist(iter, lst, ref):
knownkey, knownvalue = next(iter(self.other.items())) knownkey, knownvalue = next(iter(self.other.items()))
self.assertEqual(d.get(key, knownvalue), value) self.assertEqual(d.get(key, knownvalue), value)
self.assertEqual(d.get(knownkey, knownvalue), knownvalue) self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
self.failIf(knownkey in d) self.assertFalse(knownkey in d)
def test_write(self): def test_write(self):
# Test for write operations on mapping # Test for write operations on mapping
@ -96,7 +96,7 @@ def test_write(self):
self.assertEqual(p[key], value) self.assertEqual(p[key], value)
for key in self.reference.keys(): for key in self.reference.keys():
del p[key] del p[key]
self.failUnlessRaises(KeyError, lambda:p[key]) self.assertRaises(KeyError, lambda:p[key])
p = self._empty_mapping() p = self._empty_mapping()
#update #update
p.update(self.reference) p.update(self.reference)
@ -115,16 +115,16 @@ def test_write(self):
self.assertEqual(d[knownkey], knownvalue) self.assertEqual(d[knownkey], knownvalue)
#pop #pop
self.assertEqual(d.pop(knownkey), knownvalue) self.assertEqual(d.pop(knownkey), knownvalue)
self.failIf(knownkey in d) self.assertFalse(knownkey in d)
self.assertRaises(KeyError, d.pop, knownkey) self.assertRaises(KeyError, d.pop, knownkey)
default = 909 default = 909
d[knownkey] = knownvalue d[knownkey] = knownvalue
self.assertEqual(d.pop(knownkey, default), knownvalue) self.assertEqual(d.pop(knownkey, default), knownvalue)
self.failIf(knownkey in d) self.assertFalse(knownkey in d)
self.assertEqual(d.pop(knownkey, default), default) self.assertEqual(d.pop(knownkey, default), default)
#popitem #popitem
key, value = d.popitem() key, value = d.popitem()
self.failIf(key in d) self.assertFalse(key in d)
self.assertEqual(value, self.reference[key]) self.assertEqual(value, self.reference[key])
p=self._empty_mapping() p=self._empty_mapping()
self.assertRaises(KeyError, p.popitem) self.assertRaises(KeyError, p.popitem)
@ -133,17 +133,17 @@ def test_constructor(self):
self.assertEqual(self._empty_mapping(), self._empty_mapping()) self.assertEqual(self._empty_mapping(), self._empty_mapping())
def test_bool(self): def test_bool(self):
self.assert_(not self._empty_mapping()) self.assertTrue(not self._empty_mapping())
self.assert_(self.reference) self.assertTrue(self.reference)
self.assert_(bool(self._empty_mapping()) is False) self.assertTrue(bool(self._empty_mapping()) is False)
self.assert_(bool(self.reference) is True) self.assertTrue(bool(self.reference) is True)
def test_keys(self): def test_keys(self):
d = self._empty_mapping() d = self._empty_mapping()
self.assertEqual(list(d.keys()), []) self.assertEqual(list(d.keys()), [])
d = self.reference d = self.reference
self.assert_(list(self.inmapping.keys())[0] in d.keys()) self.assertTrue(list(self.inmapping.keys())[0] in d.keys())
self.assert_(list(self.other.keys())[0] not in d.keys()) self.assertTrue(list(self.other.keys())[0] not in d.keys())
self.assertRaises(TypeError, d.keys, None) self.assertRaises(TypeError, d.keys, None)
def test_values(self): def test_values(self):
@ -268,10 +268,10 @@ def __next__(self):
def test_get(self): def test_get(self):
d = self._empty_mapping() d = self._empty_mapping()
self.assert_(d.get(list(self.other.keys())[0]) is None) self.assertTrue(d.get(list(self.other.keys())[0]) is None)
self.assertEqual(d.get(list(self.other.keys())[0], 3), 3) self.assertEqual(d.get(list(self.other.keys())[0], 3), 3)
d = self.reference d = self.reference
self.assert_(d.get(list(self.other.keys())[0]) is None) self.assertTrue(d.get(list(self.other.keys())[0]) is None)
self.assertEqual(d.get(list(self.other.keys())[0], 3), 3) self.assertEqual(d.get(list(self.other.keys())[0], 3), 3)
self.assertEqual(d.get(list(self.inmapping.keys())[0]), self.assertEqual(d.get(list(self.inmapping.keys())[0]),
list(self.inmapping.values())[0]) list(self.inmapping.values())[0])
@ -304,15 +304,15 @@ def test_pop(self):
class TestMappingProtocol(BasicTestMappingProtocol): class TestMappingProtocol(BasicTestMappingProtocol):
def test_constructor(self): def test_constructor(self):
BasicTestMappingProtocol.test_constructor(self) BasicTestMappingProtocol.test_constructor(self)
self.assert_(self._empty_mapping() is not self._empty_mapping()) self.assertTrue(self._empty_mapping() is not self._empty_mapping())
self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2}) self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2})
def test_bool(self): def test_bool(self):
BasicTestMappingProtocol.test_bool(self) BasicTestMappingProtocol.test_bool(self)
self.assert_(not self._empty_mapping()) self.assertTrue(not self._empty_mapping())
self.assert_(self._full_mapping({"x": "y"})) self.assertTrue(self._full_mapping({"x": "y"}))
self.assert_(bool(self._empty_mapping()) is False) self.assertTrue(bool(self._empty_mapping()) is False)
self.assert_(bool(self._full_mapping({"x": "y"})) is True) self.assertTrue(bool(self._full_mapping({"x": "y"})) is True)
def test_keys(self): def test_keys(self):
BasicTestMappingProtocol.test_keys(self) BasicTestMappingProtocol.test_keys(self)
@ -320,9 +320,9 @@ def test_keys(self):
self.assertEqual(list(d.keys()), []) self.assertEqual(list(d.keys()), [])
d = self._full_mapping({'a': 1, 'b': 2}) d = self._full_mapping({'a': 1, 'b': 2})
k = d.keys() k = d.keys()
self.assert_('a' in k) self.assertTrue('a' in k)
self.assert_('b' in k) self.assertTrue('b' in k)
self.assert_('c' not in k) self.assertTrue('c' not in k)
def test_values(self): def test_values(self):
BasicTestMappingProtocol.test_values(self) BasicTestMappingProtocol.test_values(self)
@ -337,12 +337,12 @@ def test_items(self):
def test_contains(self): def test_contains(self):
d = self._empty_mapping() d = self._empty_mapping()
self.assert_(not ('a' in d)) self.assertTrue(not ('a' in d))
self.assert_('a' not in d) self.assertTrue('a' not in d)
d = self._full_mapping({'a': 1, 'b': 2}) d = self._full_mapping({'a': 1, 'b': 2})
self.assert_('a' in d) self.assertTrue('a' in d)
self.assert_('b' in d) self.assertTrue('b' in d)
self.assert_('c' not in d) self.assertTrue('c' not in d)
self.assertRaises(TypeError, d.__contains__) self.assertRaises(TypeError, d.__contains__)
@ -421,7 +421,7 @@ def __getitem__(self, i):
def test_fromkeys(self): def test_fromkeys(self):
self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
d = self._empty_mapping() d = self._empty_mapping()
self.assert_(not(d.fromkeys('abc') is d)) self.assertTrue(not(d.fromkeys('abc') is d))
self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0}) self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
self.assertEqual(d.fromkeys([]), {}) self.assertEqual(d.fromkeys([]), {})
@ -432,17 +432,17 @@ def g():
class dictlike(self.type2test): pass class dictlike(self.type2test): pass
self.assertEqual(dictlike.fromkeys('a'), {'a':None}) self.assertEqual(dictlike.fromkeys('a'), {'a':None})
self.assertEqual(dictlike().fromkeys('a'), {'a':None}) self.assertEqual(dictlike().fromkeys('a'), {'a':None})
self.assert_(dictlike.fromkeys('a').__class__ is dictlike) self.assertTrue(dictlike.fromkeys('a').__class__ is dictlike)
self.assert_(dictlike().fromkeys('a').__class__ is dictlike) self.assertTrue(dictlike().fromkeys('a').__class__ is dictlike)
# FIXME: the following won't work with UserDict, because it's an old style class # FIXME: the following won't work with UserDict, because it's an old style class
# self.assert_(type(dictlike.fromkeys('a')) is dictlike) # self.assertTrue(type(dictlike.fromkeys('a')) is dictlike)
class mydict(self.type2test): class mydict(self.type2test):
def __new__(cls): def __new__(cls):
return collections.UserDict() return collections.UserDict()
ud = mydict.fromkeys('ab') ud = mydict.fromkeys('ab')
self.assertEqual(ud, {'a':None, 'b':None}) self.assertEqual(ud, {'a':None, 'b':None})
# FIXME: the following won't work with UserDict, because it's an old style class # FIXME: the following won't work with UserDict, because it's an old style class
# self.assert_(isinstance(ud, collections.UserDict)) # self.assertTrue(isinstance(ud, collections.UserDict))
self.assertRaises(TypeError, dict.fromkeys) self.assertRaises(TypeError, dict.fromkeys)
class Exc(Exception): pass class Exc(Exception): pass
@ -472,16 +472,16 @@ def test_copy(self):
self.assertEqual(d.copy(), {1:1, 2:2, 3:3}) self.assertEqual(d.copy(), {1:1, 2:2, 3:3})
d = self._empty_mapping() d = self._empty_mapping()
self.assertEqual(d.copy(), d) self.assertEqual(d.copy(), d)
self.assert_(isinstance(d.copy(), d.__class__)) self.assertTrue(isinstance(d.copy(), d.__class__))
self.assertRaises(TypeError, d.copy, None) self.assertRaises(TypeError, d.copy, None)
def test_get(self): def test_get(self):
BasicTestMappingProtocol.test_get(self) BasicTestMappingProtocol.test_get(self)
d = self._empty_mapping() d = self._empty_mapping()
self.assert_(d.get('c') is None) self.assertTrue(d.get('c') is None)
self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('c', 3), 3)
d = self._full_mapping({'a' : 1, 'b' : 2}) d = self._full_mapping({'a' : 1, 'b' : 2})
self.assert_(d.get('c') is None) self.assertTrue(d.get('c') is None)
self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('c', 3), 3)
self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a'), 1)
self.assertEqual(d.get('a', 3), 1) self.assertEqual(d.get('a', 3), 1)
@ -489,9 +489,9 @@ def test_get(self):
def test_setdefault(self): def test_setdefault(self):
BasicTestMappingProtocol.test_setdefault(self) BasicTestMappingProtocol.test_setdefault(self)
d = self._empty_mapping() d = self._empty_mapping()
self.assert_(d.setdefault('key0') is None) self.assertTrue(d.setdefault('key0') is None)
d.setdefault('key0', []) d.setdefault('key0', [])
self.assert_(d.setdefault('key0') is None) self.assertTrue(d.setdefault('key0') is None)
d.setdefault('key', []).append(3) d.setdefault('key', []).append(3)
self.assertEqual(d['key'][0], 3) self.assertEqual(d['key'][0], 3)
d.setdefault('key', []).append(4) d.setdefault('key', []).append(4)
@ -517,9 +517,9 @@ def test_popitem(self):
self.assertEqual(va, int(ka)) self.assertEqual(va, int(ka))
kb, vb = tb = b.popitem() kb, vb = tb = b.popitem()
self.assertEqual(vb, int(kb)) self.assertEqual(vb, int(kb))
self.assert_(not(copymode < 0 and ta != tb)) self.assertTrue(not(copymode < 0 and ta != tb))
self.assert_(not a) self.assertTrue(not a)
self.assert_(not b) self.assertTrue(not b)
def test_pop(self): def test_pop(self):
BasicTestMappingProtocol.test_pop(self) BasicTestMappingProtocol.test_pop(self)
@ -577,7 +577,7 @@ def __new__(cls):
return collections.UserDict() return collections.UserDict()
ud = mydict.fromkeys('ab') ud = mydict.fromkeys('ab')
self.assertEqual(ud, {'a':None, 'b':None}) self.assertEqual(ud, {'a':None, 'b':None})
self.assert_(isinstance(ud, collections.UserDict)) self.assertTrue(isinstance(ud, collections.UserDict))
def test_pop(self): def test_pop(self):
TestMappingProtocol.test_pop(self) TestMappingProtocol.test_pop(self)

26
Lib/test/pickletester.py
View file

@ -449,7 +449,7 @@ def test_recursive_list(self):
s = self.dumps(l, proto) s = self.dumps(l, proto)
x = self.loads(s) x = self.loads(s)
self.assertEqual(len(x), 1) self.assertEqual(len(x), 1)
self.assert_(x is x[0]) self.assertTrue(x is x[0])
def test_recursive_tuple(self): def test_recursive_tuple(self):
t = ([],) t = ([],)
@ -459,7 +459,7 @@ def test_recursive_tuple(self):
x = self.loads(s) x = self.loads(s)
self.assertEqual(len(x), 1) self.assertEqual(len(x), 1)
self.assertEqual(len(x[0]), 1) self.assertEqual(len(x[0]), 1)
self.assert_(x is x[0][0]) self.assertTrue(x is x[0][0])
def test_recursive_dict(self): def test_recursive_dict(self):
d = {} d = {}
@ -468,7 +468,7 @@ def test_recursive_dict(self):
s = self.dumps(d, proto) s = self.dumps(d, proto)
x = self.loads(s) x = self.loads(s)
self.assertEqual(list(x.keys()), [1]) self.assertEqual(list(x.keys()), [1])
self.assert_(x[1] is x) self.assertTrue(x[1] is x)
def test_recursive_inst(self): def test_recursive_inst(self):
i = C() i = C()
@ -477,7 +477,7 @@ def test_recursive_inst(self):
s = self.dumps(i, 2) s = self.dumps(i, 2)
x = self.loads(s) x = self.loads(s)
self.assertEqual(dir(x), dir(i)) self.assertEqual(dir(x), dir(i))
self.assert_(x.attr is x) self.assertTrue(x.attr is x)
def test_recursive_multi(self): def test_recursive_multi(self):
l = [] l = []
@ -491,7 +491,7 @@ def test_recursive_multi(self):
self.assertEqual(len(x), 1) self.assertEqual(len(x), 1)
self.assertEqual(dir(x[0]), dir(i)) self.assertEqual(dir(x[0]), dir(i))
self.assertEqual(list(x[0].attr.keys()), [1]) self.assertEqual(list(x[0].attr.keys()), [1])
self.assert_(x[0].attr[1] is x) self.assertTrue(x[0].attr[1] is x)
def test_get(self): def test_get(self):
self.assertRaises(KeyError, self.loads, b'g0\np0') self.assertRaises(KeyError, self.loads, b'g0\np0')
@ -639,7 +639,7 @@ def test_proto(self):
try: try:
self.loads(badpickle) self.loads(badpickle)
except ValueError as detail: except ValueError as detail:
self.failUnless(str(detail).startswith( self.assertTrue(str(detail).startswith(
"unsupported pickle protocol")) "unsupported pickle protocol"))
else: else:
self.fail("expected bad protocol number to raise ValueError") self.fail("expected bad protocol number to raise ValueError")
@ -720,7 +720,7 @@ def test_singletons(self):
for x in None, False, True: for x in None, False, True:
s = self.dumps(x, proto) s = self.dumps(x, proto)
y = self.loads(s) y = self.loads(s)
self.assert_(x is y, (proto, x, s, y)) self.assertTrue(x is y, (proto, x, s, y))
expected = expected_opcode[proto, x] expected = expected_opcode[proto, x]
self.assertEqual(opcode_in_pickle(expected, s), True) self.assertEqual(opcode_in_pickle(expected, s), True)
@ -770,8 +770,8 @@ def produce_global_ext(self, extcode, opcode):
# Dump using protocol 1 for comparison. # Dump using protocol 1 for comparison.
s1 = self.dumps(x, 1) s1 = self.dumps(x, 1)
self.assert_(__name__.encode("utf-8") in s1) self.assertTrue(__name__.encode("utf-8") in s1)
self.assert_(b"MyList" in s1) self.assertTrue(b"MyList" in s1)
self.assertEqual(opcode_in_pickle(opcode, s1), False) self.assertEqual(opcode_in_pickle(opcode, s1), False)
y = self.loads(s1) y = self.loads(s1)
@ -780,8 +780,8 @@ def produce_global_ext(self, extcode, opcode):
# Dump using protocol 2 for test. # Dump using protocol 2 for test.
s2 = self.dumps(x, 2) s2 = self.dumps(x, 2)
self.assert_(__name__.encode("utf-8") not in s2) self.assertTrue(__name__.encode("utf-8") not in s2)
self.assert_(b"MyList" not in s2) self.assertTrue(b"MyList" not in s2)
self.assertEqual(opcode_in_pickle(opcode, s2), True, repr(s2)) self.assertEqual(opcode_in_pickle(opcode, s2), True, repr(s2))
y = self.loads(s2) y = self.loads(s2)
@ -825,7 +825,7 @@ def test_list_chunking(self):
if proto == 0: if proto == 0:
self.assertEqual(num_appends, 0) self.assertEqual(num_appends, 0)
else: else:
self.failUnless(num_appends >= 2) self.assertTrue(num_appends >= 2)
def test_dict_chunking(self): def test_dict_chunking(self):
n = 10 # too small to chunk n = 10 # too small to chunk
@ -848,7 +848,7 @@ def test_dict_chunking(self):
if proto == 0: if proto == 0:
self.assertEqual(num_setitems, 0) self.assertEqual(num_setitems, 0)
else: else:
self.failUnless(num_setitems >= 2) self.assertTrue(num_setitems >= 2)
def test_simple_newobj(self): def test_simple_newobj(self):
x = object.__new__(SimpleNewObj) # avoid __init__ x = object.__new__(SimpleNewObj) # avoid __init__

2
Lib/test/test___all__.py
View file

@ -17,7 +17,7 @@ def check_all(self, modname):
# Silent fail here seems the best route since some modules # Silent fail here seems the best route since some modules
# may not be available in all environments. # may not be available in all environments.
return return
self.failUnless(hasattr(sys.modules[modname], "__all__"), self.assertTrue(hasattr(sys.modules[modname], "__all__"),
"%s has no __all__ attribute" % modname) "%s has no __all__ attribute" % modname)
names = {} names = {}
exec("from %s import *" % modname, names) exec("from %s import *" % modname, names)

4
Lib/test/test___future__.py
View file

@ -15,7 +15,7 @@ def test_names(self):
for name in dir(__future__): for name in dir(__future__):
obj = getattr(__future__, name, None) obj = getattr(__future__, name, None)
if obj is not None and isinstance(obj, __future__._Feature): if obj is not None and isinstance(obj, __future__._Feature):
self.assert_( self.assertTrue(
name in given_feature_names, name in given_feature_names,
"%r should have been in all_feature_names" % name "%r should have been in all_feature_names" % name
) )
@ -30,7 +30,7 @@ def test_attributes(self):
optional = value.getOptionalRelease() optional = value.getOptionalRelease()
mandatory = value.getMandatoryRelease() mandatory = value.getMandatoryRelease()
a = self.assert_ a = self.assertTrue
e = self.assertEqual e = self.assertEqual
def check(t, name): def check(t, name):
a(isinstance(t, tuple), "%s isn't tuple" % name) a(isinstance(t, tuple), "%s isn't tuple" % name)

52
Lib/test/test_abc.py
View file

@ -42,23 +42,23 @@ def foo(self): pass # abstract
def bar(self): pass # concrete def bar(self): pass # concrete
self.assertEqual(C.__abstractmethods__, {"foo"}) self.assertEqual(C.__abstractmethods__, {"foo"})
self.assertRaises(TypeError, C) # because foo is abstract self.assertRaises(TypeError, C) # because foo is abstract
self.assert_(isabstract(C)) self.assertTrue(isabstract(C))
class D(C): class D(C):
def bar(self): pass # concrete override of concrete def bar(self): pass # concrete override of concrete
self.assertEqual(D.__abstractmethods__, {"foo"}) self.assertEqual(D.__abstractmethods__, {"foo"})
self.assertRaises(TypeError, D) # because foo is still abstract self.assertRaises(TypeError, D) # because foo is still abstract
self.assert_(isabstract(D)) self.assertTrue(isabstract(D))
class E(D): class E(D):
def foo(self): pass def foo(self): pass
self.assertEqual(E.__abstractmethods__, set()) self.assertEqual(E.__abstractmethods__, set())
E() # now foo is concrete, too E() # now foo is concrete, too
self.failIf(isabstract(E)) self.assertFalse(isabstract(E))
class F(E): class F(E):
@abstractthing @abstractthing
def bar(self): pass # abstract override of concrete def bar(self): pass # abstract override of concrete
self.assertEqual(F.__abstractmethods__, {"bar"}) self.assertEqual(F.__abstractmethods__, {"bar"})
self.assertRaises(TypeError, F) # because bar is abstract now self.assertRaises(TypeError, F) # because bar is abstract now
self.assert_(isabstract(F)) self.assertTrue(isabstract(F))
def test_subclass_oldstyle_class(self): def test_subclass_oldstyle_class(self):
class A: class A:
@ -142,41 +142,41 @@ class C(A):
def test_registration_transitiveness(self): def test_registration_transitiveness(self):
class A(metaclass=abc.ABCMeta): class A(metaclass=abc.ABCMeta):
pass pass
self.failUnless(issubclass(A, A)) self.assertTrue(issubclass(A, A))
self.failUnless(issubclass(A, (A,))) self.assertTrue(issubclass(A, (A,)))
class B(metaclass=abc.ABCMeta): class B(metaclass=abc.ABCMeta):
pass pass
self.failIf(issubclass(A, B)) self.assertFalse(issubclass(A, B))
self.failIf(issubclass(A, (B,))) self.assertFalse(issubclass(A, (B,)))
self.failIf(issubclass(B, A)) self.assertFalse(issubclass(B, A))
self.failIf(issubclass(B, (A,))) self.assertFalse(issubclass(B, (A,)))
class C(metaclass=abc.ABCMeta): class C(metaclass=abc.ABCMeta):
pass pass
A.register(B) A.register(B)
class B1(B): class B1(B):
pass pass
self.failUnless(issubclass(B1, A)) self.assertTrue(issubclass(B1, A))
self.failUnless(issubclass(B1, (A,))) self.assertTrue(issubclass(B1, (A,)))
class C1(C): class C1(C):
pass pass
B1.register(C1) B1.register(C1)
self.failIf(issubclass(C, B)) self.assertFalse(issubclass(C, B))
self.failIf(issubclass(C, (B,))) self.assertFalse(issubclass(C, (B,)))
self.failIf(issubclass(C, B1)) self.assertFalse(issubclass(C, B1))
self.failIf(issubclass(C, (B1,))) self.assertFalse(issubclass(C, (B1,)))
self.failUnless(issubclass(C1, A)) self.assertTrue(issubclass(C1, A))
self.failUnless(issubclass(C1, (A,))) self.assertTrue(issubclass(C1, (A,)))
self.failUnless(issubclass(C1, B)) self.assertTrue(issubclass(C1, B))
self.failUnless(issubclass(C1, (B,))) self.assertTrue(issubclass(C1, (B,)))
self.failUnless(issubclass(C1, B1)) self.assertTrue(issubclass(C1, B1))
self.failUnless(issubclass(C1, (B1,))) self.assertTrue(issubclass(C1, (B1,)))
C1.register(int) C1.register(int)
class MyInt(int): class MyInt(int):
pass pass
self.failUnless(issubclass(MyInt, A)) self.assertTrue(issubclass(MyInt, A))
self.failUnless(issubclass(MyInt, (A,))) self.assertTrue(issubclass(MyInt, (A,)))
self.failUnless(isinstance(42, A)) self.assertTrue(isinstance(42, A))
self.failUnless(isinstance(42, (A,))) self.assertTrue(isinstance(42, (A,)))
def test_all_new_methods_are_called(self): def test_all_new_methods_are_called(self):
class A(metaclass=abc.ABCMeta): class A(metaclass=abc.ABCMeta):

12
Lib/test/test_abstract_numbers.py
View file

@ -9,8 +9,8 @@
class TestNumbers(unittest.TestCase): class TestNumbers(unittest.TestCase):
def test_int(self): def test_int(self):
self.failUnless(issubclass(int, Integral)) self.assertTrue(issubclass(int, Integral))
self.failUnless(issubclass(int, Complex)) self.assertTrue(issubclass(int, Complex))
self.assertEqual(7, int(7).real) self.assertEqual(7, int(7).real)
self.assertEqual(0, int(7).imag) self.assertEqual(0, int(7).imag)
@ -19,16 +19,16 @@ def test_int(self):
self.assertEqual(1, int(7).denominator) self.assertEqual(1, int(7).denominator)
def test_float(self): def test_float(self):
self.failIf(issubclass(float, Rational)) self.assertFalse(issubclass(float, Rational))
self.failUnless(issubclass(float, Real)) self.assertTrue(issubclass(float, Real))
self.assertEqual(7.3, float(7.3).real) self.assertEqual(7.3, float(7.3).real)
self.assertEqual(0, float(7.3).imag) self.assertEqual(0, float(7.3).imag)
self.assertEqual(7.3, float(7.3).conjugate()) self.assertEqual(7.3, float(7.3).conjugate())
def test_complex(self): def test_complex(self):
self.failIf(issubclass(complex, Real)) self.assertFalse(issubclass(complex, Real))
self.failUnless(issubclass(complex, Complex)) self.assertTrue(issubclass(complex, Complex))
c1, c2 = complex(3, 2), complex(4,1) c1, c2 = complex(3, 2), complex(4,1)
# XXX: This is not ideal, but see the comment in math_trunc(). # XXX: This is not ideal, but see the comment in math_trunc().

70
Lib/test/test_array.py
View file

@ -49,7 +49,7 @@ def badtypecode(self):
def test_constructor(self): def test_constructor(self):
a = array.array(self.typecode) a = array.array(self.typecode)
self.assertEqual(a.typecode, self.typecode) self.assertEqual(a.typecode, self.typecode)
self.assert_(a.itemsize>=self.minitemsize) self.assertTrue(a.itemsize>=self.minitemsize)
self.assertRaises(TypeError, array.array, self.typecode, None) self.assertRaises(TypeError, array.array, self.typecode, None)
def test_len(self): def test_len(self):
@ -64,10 +64,10 @@ def test_buffer_info(self):
a = array.array(self.typecode, self.example) a = array.array(self.typecode, self.example)
self.assertRaises(TypeError, a.buffer_info, 42) self.assertRaises(TypeError, a.buffer_info, 42)
bi = a.buffer_info() bi = a.buffer_info()
self.assert_(isinstance(bi, tuple)) self.assertTrue(isinstance(bi, tuple))
self.assertEqual(len(bi), 2) self.assertEqual(len(bi), 2)
self.assert_(isinstance(bi[0], int)) self.assertTrue(isinstance(bi[0], int))
self.assert_(isinstance(bi[1], int)) self.assertTrue(isinstance(bi[1], int))
self.assertEqual(bi[1], len(a)) self.assertEqual(bi[1], len(a))
def test_byteswap(self): def test_byteswap(self):
@ -216,39 +216,39 @@ def test_str(self):
def test_cmp(self): def test_cmp(self):
a = array.array(self.typecode, self.example) a = array.array(self.typecode, self.example)
self.assert_((a == 42) is False) self.assertTrue((a == 42) is False)
self.assert_((a != 42) is True) self.assertTrue((a != 42) is True)
self.assert_((a == a) is True) self.assertTrue((a == a) is True)
self.assert_((a != a) is False) self.assertTrue((a != a) is False)
self.assert_((a < a) is False) self.assertTrue((a < a) is False)
self.assert_((a <= a) is True) self.assertTrue((a <= a) is True)
self.assert_((a > a) is False) self.assertTrue((a > a) is False)
self.assert_((a >= a) is True) self.assertTrue((a >= a) is True)
al = array.array(self.typecode, self.smallerexample) al = array.array(self.typecode, self.smallerexample)
ab = array.array(self.typecode, self.biggerexample) ab = array.array(self.typecode, self.biggerexample)
self.assert_((a == 2*a) is False) self.assertTrue((a == 2*a) is False)
self.assert_((a != 2*a) is True) self.assertTrue((a != 2*a) is True)
self.assert_((a < 2*a) is True) self.assertTrue((a < 2*a) is True)
self.assert_((a <= 2*a) is True) self.assertTrue((a <= 2*a) is True)
self.assert_((a > 2*a) is False) self.assertTrue((a > 2*a) is False)
self.assert_((a >= 2*a) is False) self.assertTrue((a >= 2*a) is False)
self.assert_((a == al) is False) self.assertTrue((a == al) is False)
self.assert_((a != al) is True) self.assertTrue((a != al) is True)
self.assert_((a < al) is False) self.assertTrue((a < al) is False)
self.assert_((a <= al) is False) self.assertTrue((a <= al) is False)
self.assert_((a > al) is True) self.assertTrue((a > al) is True)
self.assert_((a >= al) is True) self.assertTrue((a >= al) is True)
self.assert_((a == ab) is False) self.assertTrue((a == ab) is False)
self.assert_((a != ab) is True) self.assertTrue((a != ab) is True)
self.assert_((a < ab) is True) self.assertTrue((a < ab) is True)
self.assert_((a <= ab) is True) self.assertTrue((a <= ab) is True)
self.assert_((a > ab) is False) self.assertTrue((a > ab) is False)
self.assert_((a >= ab) is False) self.assertTrue((a >= ab) is False)
def test_add(self): def test_add(self):
a = array.array(self.typecode, self.example) \ a = array.array(self.typecode, self.example) \
@ -267,7 +267,7 @@ def test_iadd(self):
a = array.array(self.typecode, self.example[::-1]) a = array.array(self.typecode, self.example[::-1])
b = a b = a
a += array.array(self.typecode, 2*self.example) a += array.array(self.typecode, 2*self.example)
self.assert_(a is b) self.assertTrue(a is b)
self.assertEqual( self.assertEqual(
a, a,
array.array(self.typecode, self.example[::-1]+2*self.example) array.array(self.typecode, self.example[::-1]+2*self.example)
@ -310,22 +310,22 @@ def test_imul(self):
b = a b = a
a *= 5 a *= 5
self.assert_(a is b) self.assertTrue(a is b)
self.assertEqual( self.assertEqual(
a, a,
array.array(self.typecode, 5*self.example) array.array(self.typecode, 5*self.example)
) )
a *= 0 a *= 0
self.assert_(a is b) self.assertTrue(a is b)
self.assertEqual(a, array.array(self.typecode)) self.assertEqual(a, array.array(self.typecode))
a *= 1000 a *= 1000
self.assert_(a is b) self.assertTrue(a is b)
self.assertEqual(a, array.array(self.typecode)) self.assertEqual(a, array.array(self.typecode))
a *= -1 a *= -1
self.assert_(a is b) self.assertTrue(a is b)
self.assertEqual(a, array.array(self.typecode)) self.assertEqual(a, array.array(self.typecode))
a = array.array(self.typecode, self.example) a = array.array(self.typecode, self.example)

10
Lib/test/test_ast.py
View file

@ -116,20 +116,20 @@ def to_tuple(t):
class AST_Tests(unittest.TestCase): class AST_Tests(unittest.TestCase):
def _assert_order(self, ast_node, parent_pos): def _assertTrueorder(self, ast_node, parent_pos):
if not isinstance(ast_node, ast.AST) or ast_node._fields is None: if not isinstance(ast_node, ast.AST) or ast_node._fields is None:
return return
if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)): if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):
node_pos = (ast_node.lineno, ast_node.col_offset) node_pos = (ast_node.lineno, ast_node.col_offset)
self.assert_(node_pos >= parent_pos) self.assertTrue(node_pos >= parent_pos)
parent_pos = (ast_node.lineno, ast_node.col_offset) parent_pos = (ast_node.lineno, ast_node.col_offset)
for name in ast_node._fields: for name in ast_node._fields:
value = getattr(ast_node, name) value = getattr(ast_node, name)
if isinstance(value, list): if isinstance(value, list):
for child in value: for child in value:
self._assert_order(child, parent_pos) self._assertTrueorder(child, parent_pos)
elif value is not None: elif value is not None:
self._assert_order(value, parent_pos) self._assertTrueorder(value, parent_pos)
def test_snippets(self): def test_snippets(self):
for input, output, kind in ((exec_tests, exec_results, "exec"), for input, output, kind in ((exec_tests, exec_results, "exec"),
@ -138,7 +138,7 @@ def test_snippets(self):
for i, o in zip(input, output): for i, o in zip(input, output):
ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST) ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
self.assertEquals(to_tuple(ast_tree), o) self.assertEquals(to_tuple(ast_tree), o)
self._assert_order(ast_tree, (0, 0)) self._assertTrueorder(ast_tree, (0, 0))
def test_slice(self): def test_slice(self):
slc = ast.parse("x[::]").body[0].value.slice slc = ast.parse("x[::]").body[0].value.slice

12
Lib/test/test_augassign.py
View file

@ -60,7 +60,7 @@ def testSequences(self):
y[1:2] += [1] y[1:2] += [1]
self.assertEquals(x, [1, 2, 1, 2, 3]) self.assertEquals(x, [1, 2, 1, 2, 3])
self.assert_(x is y) self.assertTrue(x is y)
def testCustomMethods1(self): def testCustomMethods1(self):
@ -85,23 +85,23 @@ def __iadd__(self, val):
y = x y = x
x += 10 x += 10
self.assert_(isinstance(x, aug_test)) self.assertTrue(isinstance(x, aug_test))
self.assert_(y is not x) self.assertTrue(y is not x)
self.assertEquals(x.val, 11) self.assertEquals(x.val, 11)
x = aug_test2(2) x = aug_test2(2)
y = x y = x
x += 10 x += 10
self.assert_(y is x) self.assertTrue(y is x)
self.assertEquals(x.val, 12) self.assertEquals(x.val, 12)
x = aug_test3(3) x = aug_test3(3)
y = x y = x
x += 10 x += 10
self.assert_(isinstance(x, aug_test3)) self.assertTrue(isinstance(x, aug_test3))
self.assert_(y is not x) self.assertTrue(y is not x)
self.assertEquals(x.val, 13) self.assertEquals(x.val, 13)

2
Lib/test/test_base64.py
View file

@ -204,7 +204,7 @@ def test_b16decode(self):
self.assertRaises(TypeError, base64.b16decode, "") self.assertRaises(TypeError, base64.b16decode, "")
def test_ErrorHeritage(self): def test_ErrorHeritage(self):
self.assert_(issubclass(binascii.Error, ValueError)) self.assertTrue(issubclass(binascii.Error, ValueError))

Some files were not shown because too many files have changed in this diff Show more