mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-02 21:25:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

convert usage of fail* to assert*

Browse source
This commit is contained in:
Benjamin Peterson 2009-06-30 22:57:08 +00:00
parent be96cf608f
commit 5c8da86f3a
268 changed files with 5017 additions and 5017 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 AnonTest(unittest.TestCase):
("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 AnonTest(unittest.TestCase):
("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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class ArrayTestCase(unittest.TestCase):
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 = range(42, 42+alen) new_values = 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 @@ class ArrayTestCase(unittest.TestCase):
# CharArray("abc") # CharArray("abc")
self.assertRaises(TypeError, CharArray, "abc") self.assertRaises(TypeError, CharArray, "abc")
self.failUnlessEqual(ca[0], "a") self.assertEqual(ca[0], "a")
self.failUnlessEqual(ca[1], "b") self.assertEqual(ca[1], "b")
self.failUnlessEqual(ca[2], "c") self.assertEqual(ca[2], "c")
self.failUnlessEqual(ca[-3], "a") self.assertEqual(ca[-3], "a")
self.failUnlessEqual(ca[-2], "b") self.assertEqual(ca[-2], "b")
self.failUnlessEqual(ca[-1], "c") self.assertEqual(ca[-1], "c")
self.failUnlessEqual(len(ca), 3) self.assertEqual(len(ca), 3)
# slicing is now supported, but not extended slicing (3-argument)! # slicing is now supported, but not extended slicing (3-argument)!
from operator import getslice, delitem from operator import getslice, delitem
@ -72,34 +72,34 @@ class ArrayTestCase(unittest.TestCase):
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[:], "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")
try: try:
create_unicode_buffer create_unicode_buffer
@ -109,12 +109,12 @@ class ArrayTestCase(unittest.TestCase):
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,
@ -128,7 +128,7 @@ class ArrayTestCase(unittest.TestCase):
# Create a new array type based on it: # Create a new array type based on it:
t1 = my_int * 1 t1 = my_int * 1
t2 = my_int * 1 t2 = my_int * 1
self.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 @@ class BasicWrapTestCase(unittest.TestCase):
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(u"x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0)) result = f(self.wrap(1), self.wrap(u"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 @@ class BasicWrapTestCase(unittest.TestCase):
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 @@ class BasicWrapTestCase(unittest.TestCase):
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 @@ class BasicWrapTestCase(unittest.TestCase):
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 @@ class BasicWrapTestCase(unittest.TestCase):
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 @@ class BasicWrapTestCase(unittest.TestCase):
f.argtypes = [c_longlong, MyCallback] f.argtypes = [c_longlong, MyCallback]
def callback(value): def callback(value):
self.failUnless(isinstance(value, (int, long))) self.assertTrue(isinstance(value, (int, long)))
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 @@ class BasicWrapTestCase(unittest.TestCase):
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 @@ class BasicWrapTestCase(unittest.TestCase):
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 BasicWrapTestCase(unittest.TestCase):
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 BasicWrapTestCase(unittest.TestCase):
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 @@ class C_Test(unittest.TestCase):
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 BitFieldTest(unittest.TestCase):
("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 BitFieldTest(unittest.TestCase):
("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 BitFieldTest(unittest.TestCase):
("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 BitFieldTest(unittest.TestCase):
_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 @@ class BitFieldTest(unittest.TestCase):
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 @@ class BitFieldTest(unittest.TestCase):
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 BitFieldTest(unittest.TestCase):
_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 BitFieldTest(unittest.TestCase):
# 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 str) self.assertTrue(type(b[0]) is str)
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 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_string_conversion(self): def test_string_conversion(self):
b = create_string_buffer(u"abc") b = create_string_buffer(u"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 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")
try: try:
c_wchar c_wchar
@ -39,32 +39,32 @@ class StringBufferTestCase(unittest.TestCase):
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 unicode) self.assertTrue(type(b[0]) is unicode)
b = create_unicode_buffer(u"abc") b = create_unicode_buffer(u"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 unicode) self.assertTrue(type(b[0]) is unicode)
self.failUnlessEqual(b[0], u"a") self.assertEqual(b[0], u"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 unicode) self.assertTrue(type(b[0]) is unicode)
self.failUnlessEqual(b[0], u"a") self.assertEqual(b[0], u"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 @@ class Test(unittest.TestCase):
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, 6) self.assertAlmostEqual(s.value, math.pi, 6)
s = c_float.__ctype_le__(math.pi) s = c_float.__ctype_le__(math.pi)
self.failUnlessAlmostEqual(s.value, math.pi, 6) self.assertAlmostEqual(s.value, math.pi, 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, 6) self.assertAlmostEqual(s.value, math.pi, 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 Test(unittest.TestCase):
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 Test(unittest.TestCase):
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 Test(unittest.TestCase):
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 @@ class Callbacks(unittest.TestCase):
PROTO = self.functype.im_func(typ, typ) PROTO = self.functype.im_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.im_func(typ, c_byte, typ) PROTO = self.functype.im_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 @@ class Callbacks(unittest.TestCase):
# ...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 @@ class SampleCallbacksTestCase(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
# 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 @@ class Test(unittest.TestCase):
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': "foo bar"}) self.assertEqual(array._objects, {'0': "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': "foo bar", id(array): array}) self.assertEqual(array._objects, {'0': "foo bar", id(array): array})
p[0] = "spam spam" p[0] = "spam spam"
self.failUnlessEqual(p._objects, {'0': "spam spam", id(array): array}) self.assertEqual(p._objects, {'0': "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': 'foo bar', '0': "spam spam", id(array): array}) self.assertEqual(p._objects, {'1': 'foo bar', '0': "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 @@ class Test(unittest.TestCase):
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 @@ class CFunctions(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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 @@ class Test_OpenGL_libs(unittest.TestCase):
## 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 @@ class Test(unittest.TestCase):
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 @@ class Test(unittest.TestCase):
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[:], range(16)) self.assertEqual(x[:], range(16))

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

@ -18,10 +18,10 @@ class CFuncPtrTestCase(unittest.TestCase):
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 @@ class CFuncPtrTestCase(unittest.TestCase):
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 CFuncPtrTestCase(unittest.TestCase):
## "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 CFuncPtrTestCase(unittest.TestCase):
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 @@ class CFuncPtrTestCase(unittest.TestCase):
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 @@ class CFuncPtrTestCase(unittest.TestCase):
## b.value = s ## b.value = s
## b = c_string(s) ## b = c_string(s)
self.failUnlessEqual(strtok(b, "\n"), "a") self.assertEqual(strtok(b, "\n"), "a")
self.failUnlessEqual(strtok(None, "\n"), "b") self.assertEqual(strtok(None, "\n"), "b")
self.failUnlessEqual(strtok(None, "\n"), "c") self.assertEqual(strtok(None, "\n"), "c")
self.failUnlessEqual(strtok(None, "\n"), None) self.assertEqual(strtok(None, "\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 @@ class FunctionTestCase(unittest.TestCase):
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, u"x", 3, 4, 5.0, 6.0) result = f(1, u"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 @@ class FunctionTestCase(unittest.TestCase):
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, u'\x00') self.assertEqual(result, u'\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 @@ class FunctionTestCase(unittest.TestCase):
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 @@ class FunctionTestCase(unittest.TestCase):
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("123") result = f("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 @@ class FunctionTestCase(unittest.TestCase):
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 @@ class FunctionTestCase(unittest.TestCase):
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 @@ class FunctionTestCase(unittest.TestCase):
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 @@ class FunctionTestCase(unittest.TestCase):
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 @@ class FunctionTestCase(unittest.TestCase):
f.argtypes = [c_longlong, MyCallback] f.argtypes = [c_longlong, MyCallback]
def callback(value): def callback(value):
self.failUnless(isinstance(value, (int, long))) self.assertTrue(isinstance(value, (int, long)))
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 @@ class FunctionTestCase(unittest.TestCase):
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 @@ class FunctionTestCase(unittest.TestCase):
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 FunctionTestCase(unittest.TestCase):
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 FunctionTestCase(unittest.TestCase):
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 FunctionTestCase(unittest.TestCase):
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 FunctionTestCase(unittest.TestCase):
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 @@ class FunctionTestCase(unittest.TestCase):
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 MyTestCase(unittest.TestCase):
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 @@ class InitTest(unittest.TestCase):
# 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()

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

@ -18,22 +18,22 @@ What about pointers?
""" """
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
self.failUnlessEqual(3, grc(i)) self.assertEqual(3, grc(i))
ci = c_int(i) ci = c_int(i)
self.failUnlessEqual(3, grc(i)) self.assertEqual(3, 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 = "Hello, World" s = "Hello, World"
self.failUnlessEqual(3, grc(s)) self.assertEqual(3, grc(s))
cs = c_char_p(s) cs = c_char_p(s)
self.failUnlessEqual(4, grc(s)) self.assertEqual(4, 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 ObjectsTestCase(unittest.TestCase):
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 ObjectsTestCase(unittest.TestCase):
_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,11 +76,11 @@ class ObjectsTestCase(unittest.TestCase):
x = X() x = X()
x.a = s1 x.a = s1
x.b = s2 x.b = s2
self.failUnlessEqual(x._objects, {"0": s1, "1": s2}) self.assertEqual(x._objects, {"0": s1, "1": s2})
y = Y() y = Y()
y.x = x y.x = x
self.failUnlessEqual(y._objects, {"0": {"0": s1, "1": s2}}) self.assertEqual(y._objects, {"0": {"0": s1, "1": s2}})
## x = y.x ## x = y.x
## del y ## del y
## print x._b_base_._objects ## print x._b_base_._objects
@ -91,7 +91,7 @@ class ObjectsTestCase(unittest.TestCase):
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

@ -9,9 +9,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))
@ -23,7 +23,7 @@ class LibTest(unittest.TestCase):
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, " ,,aaaadmmmnpppsss\x00") self.assertEqual(chars.raw, " ,,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 @@ class LoaderTest(unittest.TestCase):
if os.name in ("nt", "ce"): if os.name in ("nt", "ce"):
def test_load_library(self): def test_load_library(self):
self.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 @@ class LoaderTest(unittest.TestCase):
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 @@ class LoaderTest(unittest.TestCase):
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 @@ class MemFunctionsTest(unittest.TestCase):
a = create_string_buffer(1000000) a = create_string_buffer(1000000)
p = "Hello, World" p = "Hello, World"
result = memmove(a, p, len(p)) result = memmove(a, p, len(p))
self.failUnlessEqual(a.value, "Hello, World") self.assertEqual(a.value, "Hello, World")
self.failUnlessEqual(string_at(result), "Hello, World") self.assertEqual(string_at(result), "Hello, World")
self.failUnlessEqual(string_at(result, 5), "Hello") self.assertEqual(string_at(result, 5), "Hello")
self.failUnlessEqual(string_at(result, 16), "Hello, World\0\0\0\0") self.assertEqual(string_at(result, 16), "Hello, World\0\0\0\0")
self.failUnlessEqual(string_at(result, 0), "") self.assertEqual(string_at(result, 0), "")
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, "xxxxxxxxxxxxxxxx") self.assertEqual(a.value, "xxxxxxxxxxxxxxxx")
self.failUnlessEqual(string_at(result), "xxxxxxxxxxxxxxxx") self.assertEqual(string_at(result), "xxxxxxxxxxxxxxxx")
self.failUnlessEqual(string_at(a), "xxxxxxxxxxxxxxxx") self.assertEqual(string_at(a), "xxxxxxxxxxxxxxxx")
self.failUnlessEqual(string_at(a, 20), "xxxxxxxxxxxxxxxx\0\0\0\0") self.assertEqual(string_at(a, 20), "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("foo bar") s = string_at("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("foo bar", 8), "foo bar\0") self.assertEqual(string_at("foo bar", 8), "foo bar\0")
self.failUnlessEqual(string_at("foo bar", 3), "foo") self.assertEqual(string_at("foo bar", 3), "foo")
try: try:
create_unicode_buffer create_unicode_buffer
@ -68,12 +68,12 @@ class MemFunctionsTest(unittest.TestCase):
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 @@ class NumberTestCase(unittest.TestCase):
# 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 @@ class NumberTestCase(unittest.TestCase):
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(2L).value, 2.0) self.assertEqual(t(2L).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 @@ class NumberTestCase(unittest.TestCase):
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 @@ class NumberTestCase(unittest.TestCase):
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 @@ class NumberTestCase(unittest.TestCase):
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 @@ class NumberTestCase(unittest.TestCase):
# 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 @@ class NumberTestCase(unittest.TestCase):
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
@ -192,11 +192,11 @@ class NumberTestCase(unittest.TestCase):
a = array('c', 'x') a = array('c', 'x')
v = c_char.from_address(a.buffer_info()[0]) v = c_char.from_address(a.buffer_info()[0])
self.failUnlessEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
self.failUnless(type(v) is c_char) self.assertTrue(type(v) is c_char)
a[0] = '?' a[0] = '?'
self.failUnlessEqual(v.value, a[0]) self.assertEqual(v.value, a[0])
# 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):
@ -204,11 +204,11 @@ class NumberTestCase(unittest.TestCase):
# 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 @@ class SimpleTypesTestCase(unittest.TestCase):
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 @@ class SimpleTypesTestCase(unittest.TestCase):
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 @@ class SimpleTypesTestCase(unittest.TestCase):
# c_char_p.from_param on a Python String packs the string # c_char_p.from_param on a Python String packs the string
# into a cparam object # into a cparam object
s = "123" s = "123"
self.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(u"123")._obj, "123") self.assertEqual(c_char_p.from_param(u"123")._obj, "123")
self.assertRaises(UnicodeEncodeError, c_char_p.from_param, u"123\377") self.assertRaises(UnicodeEncodeError, c_char_p.from_param, u"123\377")
self.assertRaises(TypeError, c_char_p.from_param, 42) self.assertRaises(TypeError, c_char_p.from_param, 42)
@ -66,7 +66,7 @@ class SimpleTypesTestCase(unittest.TestCase):
# calling c_char_p.from_param with a c_char_p instance # calling c_char_p.from_param with a c_char_p instance
# returns the argument itself: # returns the argument itself:
a = c_char_p("123") a = c_char_p("123")
self.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 @@ class SimpleTypesTestCase(unittest.TestCase):
return return
s = u"123" s = u"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, u"123") self.assertEqual(c_wchar_p.from_param("123")._obj, u"123")
self.assertRaises(UnicodeDecodeError, c_wchar_p.from_param, "123\377") self.assertRaises(UnicodeDecodeError, c_wchar_p.from_param, "123\377")
pa = c_wchar_p.from_param(c_wchar_p(u"123")) pa = c_wchar_p.from_param(c_wchar_p(u"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 @@ class SimpleTypesTestCase(unittest.TestCase):
## 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 @@ class SimpleTypesTestCase(unittest.TestCase):
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 @@ class SimpleTypesTestCase(unittest.TestCase):
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 @@ class SimpleTypesTestCase(unittest.TestCase):
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):

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

@ -45,20 +45,20 @@ class Test(unittest.TestCase):
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))
self.failUnlessEqual(v.size, sizeof(ob)) self.assertEqual(v.size, 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(v.itemsize * n, v.size) self.assertEqual(v.itemsize * n, v.size)
except: except:
# so that we can see the failing type # so that we can see the failing type
print(tp) print(tp)
@ -69,20 +69,20 @@ class Test(unittest.TestCase):
ob = tp() ob = tp()
v = memoryview(ob) v = memoryview(ob)
try: try:
self.failUnlessEqual(v.format, fmt) self.assertEqual(v.format, fmt)
self.failUnlessEqual(v.size, sizeof(ob)) self.assertEqual(v.size, 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(v.itemsize * n, v.size) self.assertEqual(v.itemsize * n, v.size)
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 @@ class PickleTest(unittest.TestCase):
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(buffer(src)[:], self.assertEqual(buffer(src)[:],
buffer(dst)[:]) buffer(dst)[:])
def test_struct(self): def test_struct(self):
@ -36,17 +36,17 @@ class PickleTest(unittest.TestCase):
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(buffer(y)[:], self.assertEqual(buffer(y)[:],
buffer(x)[:]) buffer(x)[:])
def test_unpickable(self): def test_unpickable(self):

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

@ -17,7 +17,7 @@ class PointersTestCase(unittest.TestCase):
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 @@ class PointersTestCase(unittest.TestCase):
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 @@ class PointersTestCase(unittest.TestCase):
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 @@ class PointersTestCase(unittest.TestCase):
## 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 @@ class PointersTestCase(unittest.TestCase):
i = ct(42) i = ct(42)
p = pointer(i) p = pointer(i)
## print type(p.contents), ct ## print type(p.contents), ct
self.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 PointersTestCase(unittest.TestCase):
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 @@ class PointersTestCase(unittest.TestCase):
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 @@ class PointersTestCase(unittest.TestCase):
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(0xFFFFFFFFL).value, self.assertEqual(c_void_p(0xFFFFFFFFL).value,
c_void_p(-1).value) c_void_p(-1).value)
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFFL).value, self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFL).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(0xFFFFFFFFL).value, self.assertEqual(c_void_p(0xFFFFFFFFL).value,
0xFFFFFFFFL) 0xFFFFFFFFL)
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFFL).value, self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFL).value,
c_void_p(-1).value) c_void_p(-1).value)
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFFL).value, self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFFL).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 @@ class PointersTestCase(unittest.TestCase):
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 @@ class CharPointersTestCase(unittest.TestCase):
try: try:
func() func()
except TypeError, details: except TypeError, 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 @@ class CharPointersTestCase(unittest.TestCase):
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("123")) self.assertEqual("123", func("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 @@ class CharPointersTestCase(unittest.TestCase):
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(u"123", func(c_wchar_p(u"123"))) self.assertEqual(u"123", func(c_wchar_p(u"123")))
def test_instance(self): def test_instance(self):
func = testdll._testfunc_p_p func = testdll._testfunc_p_p
@ -151,10 +151,10 @@ class CharPointersTestCase(unittest.TestCase):
_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 @@ else:
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(u"123", func(u"123")) self.assertEqual(u"123", func(u"123"))
self.failUnlessEqual(None, func(c_wchar_p(None))) self.assertEqual(None, func(c_wchar_p(None)))
self.failUnlessEqual(u"123", func(c_wchar_p(u"123"))) self.assertEqual(u"123", func(c_wchar_p(u"123")))
self.failUnlessEqual(u"123", func(c_wbuffer(u"123"))) self.assertEqual(u"123", func(c_wbuffer(u"123")))
ca = c_wchar("a") ca = c_wchar("a")
self.failUnlessEqual(u"a", func(pointer(ca))[0]) self.assertEqual(u"a", func(pointer(ca))[0])
self.failUnlessEqual(u"a", func(byref(ca))[0]) self.assertEqual(u"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 @@ else:
c_wchar_p.from_param(u"123") c_wchar_p.from_param(u"123")
self.failUnlessEqual(None, func(None)) self.assertEqual(None, func(None))
self.failUnlessEqual("123", func(u"123")) self.assertEqual("123", func(u"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 @@ class PythonAPITestCase(unittest.TestCase):
PyString_FromStringAndSize.restype = py_object PyString_FromStringAndSize.restype = py_object
PyString_FromStringAndSize.argtypes = c_char_p, c_py_ssize_t PyString_FromStringAndSize.argtypes = c_char_p, c_py_ssize_t
self.failUnlessEqual(PyString_FromStringAndSize("abcdefghi", 3), "abc") self.assertEqual(PyString_FromStringAndSize("abcdefghi", 3), "abc")
def test_PyString_FromString(self): def test_PyString_FromString(self):
pythonapi.PyString_FromString.restype = py_object pythonapi.PyString_FromString.restype = py_object
@ -32,10 +32,10 @@ class PythonAPITestCase(unittest.TestCase):
s = "abc" s = "abc"
refcnt = grc(s) refcnt = grc(s)
pyob = pythonapi.PyString_FromString(s) pyob = pythonapi.PyString_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 @@ class PythonAPITestCase(unittest.TestCase):
def test_PyInt_Long(self): def test_PyInt_Long(self):
ref42 = grc(42) ref42 = grc(42)
pythonapi.PyInt_FromLong.restype = py_object pythonapi.PyInt_FromLong.restype = py_object
self.failUnlessEqual(pythonapi.PyInt_FromLong(42), 42) self.assertEqual(pythonapi.PyInt_FromLong(42), 42)
self.failUnlessEqual(grc(42), ref42) self.assertEqual(grc(42), ref42)
pythonapi.PyInt_AsLong.argtypes = (py_object,) pythonapi.PyInt_AsLong.argtypes = (py_object,)
pythonapi.PyInt_AsLong.restype = c_long pythonapi.PyInt_AsLong.restype = c_long
res = pythonapi.PyInt_AsLong(42) res = pythonapi.PyInt_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 @@ class PythonAPITestCase(unittest.TestCase):
buf = c_buffer(256) buf = c_buffer(256)
PyOS_snprintf(buf, sizeof(buf), "Hello from %s", "ctypes") PyOS_snprintf(buf, sizeof(buf), "Hello from %s", "ctypes")
self.failUnlessEqual(buf.value, "Hello from ctypes") self.assertEqual(buf.value, "Hello from ctypes")
PyOS_snprintf(buf, sizeof(buf), "Hello from %s", "ctypes", 1, 2, 3) PyOS_snprintf(buf, sizeof(buf), "Hello from %s", "ctypes", 1, 2, 3)
self.failUnlessEqual(buf.value, "Hello from ctypes") self.assertEqual(buf.value, "Hello from ctypes")
# 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 @@ if sys.platform == "win32":
hdll = windll.kernel32.LoadLibraryA("kernel32") hdll = windll.kernel32.LoadLibraryA("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 @@ class CallbackTracbackTestCase(unittest.TestCase):
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 @@ class RefcountTestCase(unittest.TestCase):
#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 @@ class RefcountTestCase(unittest.TestCase):
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 RefcountTestCase(unittest.TestCase):
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 @@ class AnotherLeak(unittest.TestCase):
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('x')", repr(c_char('x'))) self.assertEqual("c_char('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()

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

@ -12,8 +12,8 @@ class ReturnFuncPtrTestCase(unittest.TestCase):
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.assertRaises(ArgumentError, strchr, "abcdef", 3) self.assertRaises(ArgumentError, strchr, "abcdef", 3)
self.assertRaises(TypeError, strchr, "abcdef") self.assertRaises(TypeError, strchr, "abcdef")
@ -26,8 +26,8 @@ class ReturnFuncPtrTestCase(unittest.TestCase):
# _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) self.assertRaises(ArgumentError, strchr, "abcdef", 3)
self.assertRaises(TypeError, strchr, "abcdef") self.assertRaises(TypeError, strchr, "abcdef")

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

@ -12,8 +12,8 @@ class MyInt(c_int):
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
@ -23,7 +23,7 @@ class Test(unittest.TestCase):
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):
@ -34,24 +34,24 @@ class Test(unittest.TestCase):
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 @@ from ctypes import *
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)(*xrange(1100, 1200)) a = (c_int * 100)(*xrange(1100, 1200))
b = range(1100, 1200) b = 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], range(5, 10)) self.assertEqual(a[0:5], range(5, 10))
self.failUnlessEqual(a[0:5:], range(5, 10)) self.assertEqual(a[0:5:], range(5, 10))
self.failUnlessEqual(a[4::-1], range(9, 4, -1)) self.assertEqual(a[4::-1], range(9, 4, -1))
def test_setslice_cint(self): def test_setslice_cint(self):
a = (c_int * 100)(*xrange(1100, 1200)) a = (c_int * 100)(*xrange(1100, 1200))
b = range(1100, 1200) b = range(1100, 1200)
a[32:47] = range(32, 47) a[32:47] = range(32, 47)
self.failUnlessEqual(a[32:47], range(32, 47)) self.assertEqual(a[32:47], range(32, 47))
a[32:47] = range(132, 147) a[32:47] = range(132, 147)
self.failUnlessEqual(a[32:47:], range(132, 147)) self.assertEqual(a[32:47:], range(132, 147))
a[46:31:-1] = range(232, 247) a[46:31:-1] = range(232, 247)
self.failUnlessEqual(a[32:47:1], range(246, 231, -1)) self.assertEqual(a[32:47:1], 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 setslice, setitem from operator import setslice, setitem
@ -69,12 +69,12 @@ class SlicesTestCase(unittest.TestCase):
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,
@ -94,8 +94,8 @@ class SlicesTestCase(unittest.TestCase):
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)], range(ord("a"), ord("z")+1)) self.assertEqual(res[:len(s)], range(ord("a"), ord("z")+1))
self.failUnlessEqual(res[:len(s):], range(ord("a"), ord("z")+1)) self.assertEqual(res[:len(s):], 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):
@ -115,7 +115,7 @@ class SlicesTestCase(unittest.TestCase):
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) self.assertEqual(res, s)
finally: finally:
del dll.my_strdup.errcheck del dll.my_strdup.errcheck
@ -124,11 +124,11 @@ class SlicesTestCase(unittest.TestCase):
s = "abcdefghijklmnopqrstuvwxyz\0" s = "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:
@ -144,10 +144,10 @@ class SlicesTestCase(unittest.TestCase):
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.setslice, self.assertRaises(TypeError, operator.setslice,
@ -166,10 +166,10 @@ class SlicesTestCase(unittest.TestCase):
return return
res = dll.my_wcsdup(s) res = dll.my_wcsdup(s)
tmpl = range(ord("a"), ord("z")+1) tmpl = 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 StringPtrTestCase(unittest.TestCase):
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 StringPtrTestCase(unittest.TestCase):
# 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 @@ class StringPtrTestCase(unittest.TestCase):
# 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 @@ class StringPtrTestCase(unittest.TestCase):
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, ("c", "d", "e", "f", "\000")) self.assertEqual(x, ("c", "d", "e", "f", "\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 @@ class StringArrayTestCase(unittest.TestCase):
BUF = c_char * 4 BUF = c_char * 4
buf = BUF("a", "b", "c") buf = BUF("a", "b", "c")
self.failUnlessEqual(buf.value, "abc") self.assertEqual(buf.value, "abc")
self.failUnlessEqual(buf.raw, "abc\000") self.assertEqual(buf.raw, "abc\000")
buf.value = "ABCD" buf.value = "ABCD"
self.failUnlessEqual(buf.value, "ABCD") self.assertEqual(buf.value, "ABCD")
self.failUnlessEqual(buf.raw, "ABCD") self.assertEqual(buf.raw, "ABCD")
buf.value = "x" buf.value = "x"
self.failUnlessEqual(buf.value, "x") self.assertEqual(buf.value, "x")
self.failUnlessEqual(buf.raw, "x\000CD") self.assertEqual(buf.raw, "x\000CD")
buf[1] = "Z" buf[1] = "Z"
self.failUnlessEqual(buf.value, "xZCD") self.assertEqual(buf.value, "xZCD")
self.failUnlessEqual(buf.raw, "xZCD") self.assertEqual(buf.raw, "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 @@ class StringArrayTestCase(unittest.TestCase):
buf = c_buffer(32) buf = c_buffer(32)
buf.value = "Hello, World" buf.value = "Hello, World"
self.failUnlessEqual(buf.value, "Hello, World") self.assertEqual(buf.value, "Hello, World")
self.failUnlessRaises(TypeError, setattr, buf, "value", buffer("Hello, World")) self.assertRaises(TypeError, setattr, buf, "value", buffer("Hello, World"))
self.assertRaises(TypeError, setattr, buf, "value", buffer("abc")) self.assertRaises(TypeError, setattr, buf, "value", buffer("abc"))
self.assertRaises(ValueError, setattr, buf, "raw", buffer("x" * 100)) self.assertRaises(ValueError, setattr, buf, "raw", buffer("x" * 100))
@ -38,7 +38,7 @@ class StringArrayTestCase(unittest.TestCase):
buf = c_buffer(32) buf = c_buffer(32)
buf.raw = buffer("Hello, World") buf.raw = buffer("Hello, World")
self.failUnlessEqual(buf.value, "Hello, World") self.assertEqual(buf.value, "Hello, World")
self.assertRaises(TypeError, setattr, buf, "value", buffer("abc")) self.assertRaises(TypeError, setattr, buf, "value", buffer("abc"))
self.assertRaises(ValueError, setattr, buf, "raw", buffer("x" * 100)) self.assertRaises(ValueError, setattr, buf, "raw", buffer("x" * 100))
@ -63,16 +63,16 @@ else:
BUF = c_wchar * 4 BUF = c_wchar * 4
buf = BUF(u"a", u"b", u"c") buf = BUF(u"a", u"b", u"c")
self.failUnlessEqual(buf.value, u"abc") self.assertEqual(buf.value, u"abc")
buf.value = u"ABCD" buf.value = u"ABCD"
self.failUnlessEqual(buf.value, u"ABCD") self.assertEqual(buf.value, u"ABCD")
buf.value = u"x" buf.value = u"x"
self.failUnlessEqual(buf.value, u"x") self.assertEqual(buf.value, u"x")
buf[1] = u"Z" buf[1] = u"Z"
self.failUnlessEqual(buf.value, u"xZCD") self.assertEqual(buf.value, u"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 @@ class StringTestCase(unittest.TestCase):
# 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, u"123") self.assertRaises(TypeError, c_string, u"123")
@ -108,24 +108,24 @@ class StringTestCase(unittest.TestCase):
# New in releases later than 0.4.0: # New in releases later than 0.4.0:
# c_string(number) returns an empty string of size number # c_string(number) returns an empty string of size number
self.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 @@ else:
# XXX This behaviour is about to change: # XXX This behaviour is about to change:
# len returns the size of the internal buffer in bytes. # len returns the size of the internal buffer in bytes.
# This includes the terminating NUL character. # This includes the terminating NUL character.
self.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 == u"abcdef") self.assertTrue(cs.value == u"abcdef")
self.failUnless(c_wstring(u"abc\000def").value == u"abc") self.assertTrue(c_wstring(u"abc\000def").value == u"abc")
self.failUnless(c_wstring(u"abc\000def").value == u"abc") self.assertTrue(c_wstring(u"abc\000def").value == u"abc")
# The raw property is the total buffer contents: # The raw property is the total buffer contents:
self.failUnless(cs.raw == u"abcdef\000") self.assertTrue(cs.raw == u"abcdef\000")
self.failUnless(c_wstring(u"abc\000def").raw == u"abc\000def\000") self.assertTrue(c_wstring(u"abc\000def").raw == u"abc\000def\000")
# We can change the value: # We can change the value:
cs.value = u"ab" cs.value = u"ab"
self.failUnless(cs.value == u"ab") self.assertTrue(cs.value == u"ab")
self.failUnless(cs.raw == u"ab\000\000\000\000\000") self.assertTrue(cs.raw == u"ab\000\000\000\000\000")
self.assertRaises(TypeError, c_wstring, "123") self.assertRaises(TypeError, c_wstring, "123")
self.assertRaises(ValueError, c_wstring, 0) self.assertRaises(ValueError, c_wstring, 0)

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_", [])

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

@ -13,33 +13,33 @@ class SubclassesTest(unittest.TestCase):
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 @@ class StructureTestCase(unittest.TestCase):
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 @@ class StructureTestCase(unittest.TestCase):
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 StructureTestCase(unittest.TestCase):
_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 StructureTestCase(unittest.TestCase):
_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 StructureTestCase(unittest.TestCase):
_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 StructureTestCase(unittest.TestCase):
("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 StructureTestCase(unittest.TestCase):
("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 StructureTestCase(unittest.TestCase):
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 @@ class StructureTestCase(unittest.TestCase):
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 StructureTestCase(unittest.TestCase):
_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 StructureTestCase(unittest.TestCase):
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 StructureTestCase(unittest.TestCase):
("age", c_int)] ("age", c_int)]
p = PersonW(u"Someone") p = PersonW(u"Someone")
self.failUnlessEqual(p.name, "Someone") self.assertEqual(p.name, "Someone")
self.failUnlessEqual(PersonW(u"1234567890").name, u"1234567890") self.assertEqual(PersonW(u"1234567890").name, u"1234567890")
self.failUnlessEqual(PersonW(u"12345678901").name, u"12345678901") self.assertEqual(PersonW(u"12345678901").name, u"12345678901")
# exact fit # exact fit
self.failUnlessEqual(PersonW(u"123456789012").name, u"123456789012") self.assertEqual(PersonW(u"123456789012").name, u"123456789012")
#too long #too long
self.assertRaises(ValueError, PersonW, u"1234567890123") self.assertRaises(ValueError, PersonW, u"1234567890123")
@ -305,24 +305,24 @@ class StructureTestCase(unittest.TestCase):
("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)
# In Python 2.5, Exception is a new-style class, and the repr changed # In Python 2.5, Exception is a new-style class, and the repr changed
if issubclass(Exception, object): if issubclass(Exception, object):
self.failUnlessEqual(msg, self.assertEqual(msg,
"(Phone) <type 'exceptions.TypeError'>: " "(Phone) <type 'exceptions.TypeError'>: "
"expected string or Unicode object, int found") "expected string or Unicode object, int found")
else: else:
self.failUnlessEqual(msg, self.assertEqual(msg,
"(Phone) exceptions.TypeError: " "(Phone) exceptions.TypeError: "
"expected string or Unicode object, int found") "expected string or Unicode object, 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) <type 'exceptions.TypeError'>: too many initializers") "(Phone) <type 'exceptions.TypeError'>: too many initializers")
else: else:
self.failUnlessEqual(msg, "(Phone) exceptions.TypeError: too many initializers") self.assertEqual(msg, "(Phone) exceptions.TypeError: too many initializers")
def get_except(self, func, *args): def get_except(self, func, *args):
@ -337,7 +337,7 @@ class StructureTestCase(unittest.TestCase):
## # 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):
@ -345,15 +345,15 @@ class StructureTestCase(unittest.TestCase):
_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):
@ -366,7 +366,7 @@ class PointerMemberTestCase(unittest.TestCase):
# 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.
@ -377,14 +377,14 @@ class PointerMemberTestCase(unittest.TestCase):
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):
@ -394,7 +394,7 @@ class PointerMemberTestCase(unittest.TestCase):
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):
@ -404,7 +404,7 @@ class TestRecursiveStructure(unittest.TestCase):
try: try:
Recursive._fields_ = [("next", Recursive)] Recursive._fields_ = [("next", Recursive)]
except AttributeError, details: except AttributeError, 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")
@ -421,7 +421,7 @@ class TestRecursiveStructure(unittest.TestCase):
try: try:
Second._fields_ = [("first", First)] Second._fields_ = [("first", First)]
except AttributeError, details: except AttributeError, 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

@ -23,55 +23,55 @@ else:
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(u"abc"), 3) self.assertEqual(wcslen(u"abc"), 3)
self.failUnlessEqual(wcslen(u"ab\u2070"), 3) self.assertEqual(wcslen(u"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, "abä") self.assertRaises(ctypes.ArgumentError, wcslen, "abä")
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(u"abc"), 3) self.assertEqual(wcslen(u"abc"), 3)
self.failUnlessEqual(wcslen(u"ab\u2070"), 3) self.assertEqual(wcslen(u"ab\u2070"), 3)
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("abä"), 3) self.assertEqual(wcslen("abä"), 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(u"abc"), 3) self.assertEqual(wcslen(u"abc"), 3)
self.failUnlessEqual(wcslen(u"ab\u2070"), 3) self.assertEqual(wcslen(u"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("äöüß"), 0) self.assertEqual(wcslen("äöüß"), 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(u"abc"), 3) self.assertEqual(wcslen(u"abc"), 3)
self.failUnlessEqual(wcslen(u"ab\u2070"), 3) self.assertEqual(wcslen(u"ab\u2070"), 3)
self.failUnlessEqual(wcslen("abc"), 3) self.assertEqual(wcslen("abc"), 3)
self.failUnlessEqual(wcslen("äöüß"), 4) self.assertEqual(wcslen("äöüß"), 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("abäöü") buf = ctypes.create_unicode_buffer("abäöü")
self.failUnlessEqual(buf[:], u"ab\uFFFD\uFFFD\uFFFD\0") self.assertEqual(buf[:], u"ab\uFFFD\uFFFD\uFFFD\0")
self.failUnlessEqual(buf[::], u"ab\uFFFD\uFFFD\uFFFD\0") self.assertEqual(buf[::], u"ab\uFFFD\uFFFD\uFFFD\0")
self.failUnlessEqual(buf[::-1], u"\0\uFFFD\uFFFD\uFFFDba") self.assertEqual(buf[::-1], u"\0\uFFFD\uFFFD\uFFFDba")
self.failUnlessEqual(buf[::2], u"a\uFFFD\uFFFD") self.assertEqual(buf[::2], u"a\uFFFD\uFFFD")
self.failUnlessEqual(buf[6:5:-1], u"") self.assertEqual(buf[6:5:-1], u"")
ctypes.set_conversion_mode("ascii", "ignore") ctypes.set_conversion_mode("ascii", "ignore")
buf = ctypes.create_unicode_buffer("abäöü") buf = ctypes.create_unicode_buffer("abäöü")
# 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[:], u"ab\0\0\0\0") self.assertEqual(buf[:], u"ab\0\0\0\0")
self.failUnlessEqual(buf[::], u"ab\0\0\0\0") self.assertEqual(buf[::], u"ab\0\0\0\0")
self.failUnlessEqual(buf[::-1], u"\0\0\0\0ba") self.assertEqual(buf[::-1], u"\0\0\0\0ba")
self.failUnlessEqual(buf[::2], u"a\0\0") self.assertEqual(buf[::2], u"a\0\0")
self.failUnlessEqual(buf[6:5:-1], u"") self.assertEqual(buf[6:5:-1], u"")
import _ctypes_test import _ctypes_test
func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
@ -89,41 +89,41 @@ else:
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(u"abc"), "abc") self.assertEqual(func(u"abc"), "abc")
self.assertRaises(ctypes.ArgumentError, func, u"abä") self.assertRaises(ctypes.ArgumentError, func, u"abä")
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(u"abc"), "abc") self.assertEqual(func(u"abc"), "abc")
self.failUnlessEqual(func(u"äöüß"), "") self.assertEqual(func(u"äöüß"), "")
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(u"abc"), "abc") self.assertEqual(func(u"abc"), "abc")
self.failUnlessEqual(func(u"äöüß"), "????") self.assertEqual(func(u"äöüß"), "????")
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(u"abc") buf = ctypes.create_string_buffer(u"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(u"abäöü") buf = ctypes.create_string_buffer(u"abäöü")
self.failUnlessEqual(buf[:], "ab???\0") self.assertEqual(buf[:], "ab???\0")
self.failUnlessEqual(buf[::], "ab???\0") self.assertEqual(buf[::], "ab???\0")
self.failUnlessEqual(buf[::-1], "\0???ba") self.assertEqual(buf[::-1], "\0???ba")
self.failUnlessEqual(buf[::2], "a??") self.assertEqual(buf[::2], "a??")
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_string_buffer(u"abäöü") buf = ctypes.create_string_buffer(u"abäöü")
# 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")
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

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

@ -13,9 +13,9 @@ class ValuesTestCase(unittest.TestCase):
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())
def test_undefined(self): def test_undefined(self):
ctdll = CDLL(_ctypes_test.__file__) ctdll = CDLL(_ctypes_test.__file__)
@ -34,11 +34,11 @@ class ValuesTestCase(unittest.TestCase):
# 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
@ -70,7 +70,7 @@ class ValuesTestCase(unittest.TestCase):
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 VarSizeTest(unittest.TestCase):
_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 @@ if sys.platform == "win32" and sizeof(c_void_p) == sizeof(c_int):
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 @@ if sys.platform == "win32":
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 Structures(unittest.TestCase):
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 @@ class ArchiveUtilTestCase(support.TempdirManager,
# 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 @@ class ArchiveUtilTestCase(support.TempdirManager,
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 @@ class ArchiveUtilTestCase(support.TempdirManager,
# 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 @@ class ArchiveUtilTestCase(support.TempdirManager,
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 @@ class ArchiveUtilTestCase(support.TempdirManager,
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 @@ class ArchiveUtilTestCase(support.TempdirManager,
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 @@ class ArchiveUtilTestCase(support.TempdirManager,
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 @@ class ArchiveUtilTestCase(support.TempdirManager,
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 @@ class BuildRpmTestCase(support.TempdirManager,
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 @@ class BuildRpmTestCase(support.TempdirManager,
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 @@ class BuildWinInstTestCase(support.TempdirManager,
# 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 @@ class BuildCLibTestCase(support.TempdirManager,
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

@ -73,15 +73,15 @@ class BuildExtTestCase(support.TempdirManager,
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 @@ class BuildExtTestCase(support.TempdirManager,
_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 @@ class BuildExtTestCase(support.TempdirManager,
# 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 @@ class BuildExtTestCase(support.TempdirManager,
# 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 @@ class BuildExtTestCase(support.TempdirManager,
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 @@ class BuildExtTestCase(support.TempdirManager,
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 @@ class BuildExtTestCase(support.TempdirManager,
'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 @@ class BuildExtTestCase(support.TempdirManager,
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 @@ class BuildExtTestCase(support.TempdirManager,
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 @@ class BuildPyTestCase(support.TempdirManager,
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 @@ class BuildScriptsTestCase(support.TempdirManager,
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 @@ class BuildScriptsTestCase(support.TempdirManager,
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 @@ class cleanTestCase(support.TempdirManager,
# 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 @@ class CommandTestCase(unittest.TestCase):
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

@ -105,9 +105,9 @@ class PyPIRCCommandTestCase(support.TempdirManager,
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 @@ class ConfigTestCase(support.LoggingSilencer,
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

@ -73,7 +73,7 @@ class DistributionTestCase(support.TempdirManager,
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):
@ -204,10 +204,10 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
"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",
@ -219,9 +219,9 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
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,
@ -239,11 +239,11 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
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,
@ -261,11 +261,11 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
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,
@ -299,14 +299,14 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
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)
@ -332,7 +332,7 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
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 @@ class InstallTestCase(support.TempdirManager,
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 @@ class InstallTestCase(support.TempdirManager,
# 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 @@ class InstallDataTestCase(support.TempdirManager,
# 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 @@ class InstallDataTestCase(support.TempdirManager,
# 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 @@ class InstallDataTestCase(support.TempdirManager,
# 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 @@ class InstallLibTestCase(support.TempdirManager,
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 @@ class InstallLibTestCase(support.TempdirManager,
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 @@ class InstallScriptsTestCase(support.TempdirManager,
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 @@ class InstallScriptsTestCase(support.TempdirManager,
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 @@ class msvc9compilerTestCase(unittest.TestCase):
# windows registeries versions. # windows registeries versions.
path = r'Software\Microsoft\Notepad' path = r'Software\Microsoft\Notepad'
v = Reg.get_value(path, u"lfitalic") v = Reg.get_value(path, u"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 @@ class msvc9compilerTestCase(unittest.TestCase):
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 @@ class RegisterTestCase(PyPIRCCommandTestCase):
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 raw_input and getpass.getpass # patching raw_input and getpass.getpass
# so register gets happy # so register gets happy
@ -115,7 +115,7 @@ class RegisterTestCase(PyPIRCCommandTestCase):
del register_module.raw_input del register_module.raw_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 @@ class RegisterTestCase(PyPIRCCommandTestCase):
# 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_('xxx' in self.conn.reqs[1].data) self.assertTrue('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 @@ class RegisterTestCase(PyPIRCCommandTestCase):
del register_module.raw_input del register_module.raw_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_('tarek' in req.data) self.assertTrue('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 @@ class RegisterTestCase(PyPIRCCommandTestCase):
del register_module.raw_input del register_module.raw_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_('tarek' in req.data) self.assertTrue('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 @@ class SysconfigTestCase(support.EnvironGuard,
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 @@ class SysconfigTestCase(support.EnvironGuard,
# 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 @@ class uploadTestCase(PyPIRCCommandTestCase):
# 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'], '2086') self.assertEquals(headers['Content-length'], '2086')
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_('xxx' in self.last_open.req.data) self.assertTrue('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 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase):
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'

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

@ -50,7 +50,7 @@ def openfile(filename, mode='r'):
# 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)
@ -239,12 +239,12 @@ class TestMessageAPI(TestEmailBase):
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.assertEqual eq = self.assertEqual
@ -266,7 +266,7 @@ class TestMessageAPI(TestEmailBase):
eq(text, msg.as_string()) eq(text, msg.as_string())
fullrepr = str(msg) fullrepr = str(msg)
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):
@ -337,10 +337,10 @@ class TestMessageAPI(TestEmailBase):
def test_has_key(self): def test_has_key(self):
msg = email.message_from_string('Header: exists') msg = email.message_from_string('Header: exists')
self.failUnless(msg.has_key('header')) self.assertTrue(msg.has_key('header'))
self.failUnless(msg.has_key('Header')) self.assertTrue(msg.has_key('Header'))
self.failUnless(msg.has_key('HEADER')) self.assertTrue(msg.has_key('HEADER'))
self.failIf(msg.has_key('headeri')) self.assertFalse(msg.has_key('headeri'))
def test_set_param(self): def test_set_param(self):
eq = self.assertEqual eq = self.assertEqual
@ -931,7 +931,7 @@ class TestMIMEAudio(unittest.TestCase):
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'],
@ -974,7 +974,7 @@ class TestMIMEImage(unittest.TestCase):
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'],
@ -1001,7 +1001,7 @@ class TestMIMEText(unittest.TestCase):
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 = []
@ -1011,7 +1011,7 @@ class TestMIMEText(unittest.TestCase):
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
@ -1066,7 +1066,7 @@ This is the dingus fish.
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
@ -1380,7 +1380,7 @@ Content-Type: text/plain
-- 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)
@ -1410,7 +1410,7 @@ class TestNonConformant(TestEmailBase):
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)
@ -1420,7 +1420,7 @@ class TestNonConformant(TestEmailBase):
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)
@ -1478,7 +1478,7 @@ counter to RFC 2822, there's no separating newline here
""") """)
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)
@ -1498,7 +1498,7 @@ counter to RFC 2822, there's no separating newline here
# [*] 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):
@ -1508,7 +1508,7 @@ counter to RFC 2822, there's no separating newline here
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')
@ -1576,7 +1576,7 @@ class TestMIMEMessage(TestEmailBase):
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
@ -1620,20 +1620,20 @@ Here is the body of the message.
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')
@ -1983,7 +1983,7 @@ class TestIdempotent(TestEmailBase):
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')
@ -2005,7 +2005,7 @@ class TestIdempotent(TestEmailBase):
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)
@ -2015,7 +2015,7 @@ class TestIdempotent(TestEmailBase):
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')
@ -2025,9 +2025,9 @@ class TestIdempotent(TestEmailBase):
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')
@ -2064,7 +2064,7 @@ class TestMiscellaneous(TestEmailBase):
fp.close() fp.close()
def test_message_from_string_with_class(self): def test_message_from_string_with_class(self):
unless = self.failUnless unless = self.assertTrue
fp = openfile('msg_01.txt') fp = openfile('msg_01.txt')
try: try:
text = fp.read() text = fp.read()
@ -2087,7 +2087,7 @@ class TestMiscellaneous(TestEmailBase):
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
@ -2229,7 +2229,7 @@ Foo
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')
@ -2428,8 +2428,8 @@ class TestParsers(TestEmailBase):
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
@ -2648,15 +2648,15 @@ class TestQuopri(unittest.TestCase):
def test_header_quopri_check(self): def test_header_quopri_check(self):
for c in self.hlit: for c in self.hlit:
self.failIf(quopriMIME.header_quopri_check(c)) self.assertFalse(quopriMIME.header_quopri_check(c))
for c in self.hnon: for c in self.hnon:
self.failUnless(quopriMIME.header_quopri_check(c)) self.assertTrue(quopriMIME.header_quopri_check(c))
def test_body_quopri_check(self): def test_body_quopri_check(self):
for c in self.blit: for c in self.blit:
self.failIf(quopriMIME.body_quopri_check(c)) self.assertFalse(quopriMIME.body_quopri_check(c))
for c in self.bnon: for c in self.bnon:
self.failUnless(quopriMIME.body_quopri_check(c)) self.assertTrue(quopriMIME.body_quopri_check(c))
def test_header_quopri_len(self): def test_header_quopri_len(self):
eq = self.assertEqual eq = self.assertEqual
@ -2825,7 +2825,7 @@ class TestHeader(TestEmailBase):
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
@ -3055,7 +3055,7 @@ Content-Type: text/html; NAME*0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOC
''' '''
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')
@ -3208,7 +3208,7 @@ Content-Type: application/x-foo; name*0=\"Frank's\"; name*1=\" Document\"
""" """
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):
@ -3232,7 +3232,7 @@ Content-Type: application/x-foo;
""" """
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):

90
Lib/email/test/test_email_renamed.py
View file

@ -51,7 +51,7 @@ def openfile(filename, mode='r'):
# 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)
@ -227,12 +227,12 @@ class TestMessageAPI(TestEmailBase):
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.assertEqual eq = self.assertEqual
@ -254,7 +254,7 @@ class TestMessageAPI(TestEmailBase):
self.ndiffAssertEqual(text, msg.as_string()) self.ndiffAssertEqual(text, msg.as_string())
fullrepr = str(msg) fullrepr = str(msg)
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):
@ -325,10 +325,10 @@ class TestMessageAPI(TestEmailBase):
def test_has_key(self): def test_has_key(self):
msg = email.message_from_string('Header: exists') msg = email.message_from_string('Header: exists')
self.failUnless(msg.has_key('header')) self.assertTrue(msg.has_key('header'))
self.failUnless(msg.has_key('Header')) self.assertTrue(msg.has_key('Header'))
self.failUnless(msg.has_key('HEADER')) self.assertTrue(msg.has_key('HEADER'))
self.failIf(msg.has_key('headeri')) self.assertFalse(msg.has_key('headeri'))
def test_set_param(self): def test_set_param(self):
eq = self.assertEqual eq = self.assertEqual
@ -912,7 +912,7 @@ class TestMIMEAudio(unittest.TestCase):
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'],
@ -955,7 +955,7 @@ class TestMIMEImage(unittest.TestCase):
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'],
@ -999,7 +999,7 @@ class TestMIMEText(unittest.TestCase):
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 = []
@ -1009,7 +1009,7 @@ class TestMIMEText(unittest.TestCase):
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
@ -1064,7 +1064,7 @@ This is the dingus fish.
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
@ -1378,7 +1378,7 @@ Content-Type: text/plain
-- 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)
@ -1408,7 +1408,7 @@ class TestNonConformant(TestEmailBase):
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)
@ -1418,7 +1418,7 @@ class TestNonConformant(TestEmailBase):
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)
@ -1476,7 +1476,7 @@ counter to RFC 2822, there's no separating newline here
""") """)
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)
@ -1496,7 +1496,7 @@ counter to RFC 2822, there's no separating newline here
# [*] 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):
@ -1506,7 +1506,7 @@ counter to RFC 2822, there's no separating newline here
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')
@ -1573,7 +1573,7 @@ class TestMIMEMessage(TestEmailBase):
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
@ -1617,20 +1617,20 @@ Here is the body of the message.
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')
@ -1977,7 +1977,7 @@ class TestIdempotent(TestEmailBase):
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')
@ -1999,7 +1999,7 @@ class TestIdempotent(TestEmailBase):
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)
@ -2009,7 +2009,7 @@ class TestIdempotent(TestEmailBase):
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')
@ -2019,9 +2019,9 @@ class TestIdempotent(TestEmailBase):
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')
@ -2058,7 +2058,7 @@ class TestMiscellaneous(TestEmailBase):
fp.close() fp.close()
def test_message_from_string_with_class(self): def test_message_from_string_with_class(self):
unless = self.failUnless unless = self.assertTrue
fp = openfile('msg_01.txt') fp = openfile('msg_01.txt')
try: try:
text = fp.read() text = fp.read()
@ -2081,7 +2081,7 @@ class TestMiscellaneous(TestEmailBase):
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
@ -2224,7 +2224,7 @@ Foo
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')
@ -2423,8 +2423,8 @@ class TestParsers(TestEmailBase):
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
@ -2643,15 +2643,15 @@ class TestQuopri(unittest.TestCase):
def test_header_quopri_check(self): def test_header_quopri_check(self):
for c in self.hlit: for c in self.hlit:
self.failIf(quoprimime.header_quopri_check(c)) self.assertFalse(quoprimime.header_quopri_check(c))
for c in self.hnon: for c in self.hnon:
self.failUnless(quoprimime.header_quopri_check(c)) self.assertTrue(quoprimime.header_quopri_check(c))
def test_body_quopri_check(self): def test_body_quopri_check(self):
for c in self.blit: for c in self.blit:
self.failIf(quoprimime.body_quopri_check(c)) self.assertFalse(quoprimime.body_quopri_check(c))
for c in self.bnon: for c in self.bnon:
self.failUnless(quoprimime.body_quopri_check(c)) self.assertTrue(quoprimime.body_quopri_check(c))
def test_header_quopri_len(self): def test_header_quopri_len(self):
eq = self.assertEqual eq = self.assertEqual
@ -2820,7 +2820,7 @@ class TestHeader(TestEmailBase):
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
@ -3050,7 +3050,7 @@ Content-Type: text/html; NAME*0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOC
''' '''
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')
@ -3203,7 +3203,7 @@ Content-Type: application/x-foo; name*0=\"Frank's\"; name*1=\" Document\"
""" """
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):
@ -3227,7 +3227,7 @@ Content-Type: application/x-foo;
""" """
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):

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

@ -8,12 +8,12 @@ from collections import OrderedDict
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_decoder_optimizations(self): def test_decoder_optimizations(self):

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

@ -7,9 +7,9 @@ from json import encoder
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)

12
Lib/lib-tk/test/test_tkinter/test_text.py
View file

@ -19,18 +19,18 @@ class TextTest(unittest.TestCase):
text = self.text text = self.text
# pattern and index are obligatory arguments. # pattern and index are obligatory arguments.
self.failUnlessRaises(Tkinter.TclError, text.search, None, '1.0') self.assertRaises(Tkinter.TclError, text.search, None, '1.0')
self.failUnlessRaises(Tkinter.TclError, text.search, 'a', None) self.assertRaises(Tkinter.TclError, text.search, 'a', None)
self.failUnlessRaises(Tkinter.TclError, text.search, None, None) self.assertRaises(Tkinter.TclError, text.search, None, None)
# Invalid text index. # Invalid text index.
self.failUnlessRaises(Tkinter.TclError, text.search, '', 0) self.assertRaises(Tkinter.TclError, text.search, '', 0)
# Check if we are getting the indices as strings -- you are likely # Check if we are getting the indices as strings -- you are likely
# to get Tcl_Obj under Tk 8.5 if Tkinter doesn't convert it. # to get Tcl_Obj under Tk 8.5 if Tkinter doesn't convert it.
text.insert('1.0', 'hi-test') text.insert('1.0', 'hi-test')
self.failUnlessEqual(text.search('-test', '1.0', 'end'), '1.2') self.assertEqual(text.search('-test', '1.0', 'end'), '1.2')
self.failUnlessEqual(text.search('test', '1.0', 'end'), '1.3') self.assertEqual(text.search('test', '1.0', 'end'), '1.3')
tests_gui = (TextTest, ) tests_gui = (TextTest, )

82
Lib/lib-tk/test/test_ttk/test_extensions.py
View file

@ -22,16 +22,16 @@ class LabeledScaleTest(unittest.TestCase):
x = ttk.LabeledScale() x = ttk.LabeledScale()
var = x._variable._name var = x._variable._name
x.destroy() x.destroy()
self.failUnlessRaises(Tkinter.TclError, x.tk.globalgetvar, var) self.assertRaises(Tkinter.TclError, x.tk.globalgetvar, var)
# manually created variable # manually created variable
myvar = Tkinter.DoubleVar() myvar = Tkinter.DoubleVar()
name = myvar._name name = myvar._name
x = ttk.LabeledScale(variable=myvar) x = ttk.LabeledScale(variable=myvar)
x.destroy() x.destroy()
self.failUnlessEqual(x.tk.globalgetvar(name), myvar.get()) self.assertEqual(x.tk.globalgetvar(name), myvar.get())
del myvar del myvar
self.failUnlessRaises(Tkinter.TclError, x.tk.globalgetvar, name) self.assertRaises(Tkinter.TclError, x.tk.globalgetvar, name)
# checking that the tracing callback is properly removed # checking that the tracing callback is properly removed
myvar = Tkinter.IntVar() myvar = Tkinter.IntVar()
@ -45,17 +45,17 @@ class LabeledScaleTest(unittest.TestCase):
# it tries calling instance attributes not yet defined. # it tries calling instance attributes not yet defined.
ttk.LabeledScale(variable=myvar) ttk.LabeledScale(variable=myvar)
if hasattr(sys, 'last_type'): if hasattr(sys, 'last_type'):
self.failIf(sys.last_type == Tkinter.TclError) self.assertFalse(sys.last_type == Tkinter.TclError)
def test_initialization(self): def test_initialization(self):
# master passing # master passing
x = ttk.LabeledScale() x = ttk.LabeledScale()
self.failUnlessEqual(x.master, Tkinter._default_root) self.assertEqual(x.master, Tkinter._default_root)
x.destroy() x.destroy()
master = Tkinter.Frame() master = Tkinter.Frame()
x = ttk.LabeledScale(master) x = ttk.LabeledScale(master)
self.failUnlessEqual(x.master, master) self.assertEqual(x.master, master)
x.destroy() x.destroy()
# variable initialization/passing # variable initialization/passing
@ -63,29 +63,29 @@ class LabeledScaleTest(unittest.TestCase):
(-1, -1), (sys.maxint + 1, sys.maxint + 1)) (-1, -1), (sys.maxint + 1, sys.maxint + 1))
for pair in passed_expected: for pair in passed_expected:
x = ttk.LabeledScale(from_=pair[0]) x = ttk.LabeledScale(from_=pair[0])
self.failUnlessEqual(x.value, pair[1]) self.assertEqual(x.value, pair[1])
x.destroy() x.destroy()
x = ttk.LabeledScale(from_='2.5') x = ttk.LabeledScale(from_='2.5')
self.failUnlessRaises(ValueError, x._variable.get) self.assertRaises(ValueError, x._variable.get)
x.destroy() x.destroy()
x = ttk.LabeledScale(from_=None) x = ttk.LabeledScale(from_=None)
self.failUnlessRaises(ValueError, x._variable.get) self.assertRaises(ValueError, x._variable.get)
x.destroy() x.destroy()
# variable should have its default value set to the from_ value # variable should have its default value set to the from_ value
myvar = Tkinter.DoubleVar(value=20) myvar = Tkinter.DoubleVar(value=20)
x = ttk.LabeledScale(variable=myvar) x = ttk.LabeledScale(variable=myvar)
self.failUnlessEqual(x.value, 0) self.assertEqual(x.value, 0)
x.destroy() x.destroy()
# check that it is really using a DoubleVar # check that it is really using a DoubleVar
x = ttk.LabeledScale(variable=myvar, from_=0.5) x = ttk.LabeledScale(variable=myvar, from_=0.5)
self.failUnlessEqual(x.value, 0.5) self.assertEqual(x.value, 0.5)
self.failUnlessEqual(x._variable._name, myvar._name) self.assertEqual(x._variable._name, myvar._name)
x.destroy() x.destroy()
# widget positionment # widget positionment
def check_positions(scale, scale_pos, label, label_pos): def check_positions(scale, scale_pos, label, label_pos):
self.failUnlessEqual(scale.pack_info()['side'], scale_pos) self.assertEqual(scale.pack_info()['side'], scale_pos)
self.failUnlessEqual(label.place_info()['anchor'], label_pos) self.assertEqual(label.place_info()['anchor'], label_pos)
x = ttk.LabeledScale(compound='top') x = ttk.LabeledScale(compound='top')
check_positions(x.scale, 'bottom', x.label, 'n') check_positions(x.scale, 'bottom', x.label, 'n')
x.destroy() x.destroy()
@ -100,7 +100,7 @@ class LabeledScaleTest(unittest.TestCase):
x.destroy() x.destroy()
# extra, and invalid, kwargs # extra, and invalid, kwargs
self.failUnlessRaises(Tkinter.TclError, ttk.LabeledScale, a='b') self.assertRaises(Tkinter.TclError, ttk.LabeledScale, a='b')
def test_horizontal_range(self): def test_horizontal_range(self):
@ -111,7 +111,7 @@ class LabeledScaleTest(unittest.TestCase):
linfo_1 = lscale.label.place_info() linfo_1 = lscale.label.place_info()
prev_xcoord = lscale.scale.coords()[0] prev_xcoord = lscale.scale.coords()[0]
self.failUnlessEqual(prev_xcoord, int(linfo_1['x'])) self.assertEqual(prev_xcoord, int(linfo_1['x']))
# change range to: from -5 to 5. This should change the x coord of # change range to: from -5 to 5. This should change the x coord of
# the scale widget, since 0 is at the middle of the new # the scale widget, since 0 is at the middle of the new
# range. # range.
@ -120,15 +120,15 @@ class LabeledScaleTest(unittest.TestCase):
# at the same time this shouldn't affect test outcome # at the same time this shouldn't affect test outcome
lscale.update() lscale.update()
curr_xcoord = lscale.scale.coords()[0] curr_xcoord = lscale.scale.coords()[0]
self.failUnless(prev_xcoord != curr_xcoord) self.assertTrue(prev_xcoord != curr_xcoord)
# the label widget should have been repositioned too # the label widget should have been repositioned too
linfo_2 = lscale.label.place_info() linfo_2 = lscale.label.place_info()
self.failUnlessEqual(lscale.label['text'], 0) self.assertEqual(lscale.label['text'], 0)
self.failUnlessEqual(curr_xcoord, int(linfo_2['x'])) self.assertEqual(curr_xcoord, int(linfo_2['x']))
# change the range back # change the range back
lscale.scale.configure(from_=0, to=10) lscale.scale.configure(from_=0, to=10)
self.failUnless(prev_xcoord != curr_xcoord) self.assertTrue(prev_xcoord != curr_xcoord)
self.failUnlessEqual(prev_xcoord, int(linfo_1['x'])) self.assertEqual(prev_xcoord, int(linfo_1['x']))
lscale.destroy() lscale.destroy()
@ -145,16 +145,16 @@ class LabeledScaleTest(unittest.TestCase):
# The following update is needed since the test doesn't use mainloop, # The following update is needed since the test doesn't use mainloop,
# at the same time this shouldn't affect test outcome # at the same time this shouldn't affect test outcome
x.update() x.update()
self.failUnlessEqual(x.label['text'], newval) self.assertEqual(x.label['text'], newval)
self.failUnless(x.scale.coords()[0] > curr_xcoord) self.assertTrue(x.scale.coords()[0] > curr_xcoord)
self.failUnlessEqual(x.scale.coords()[0], self.assertEqual(x.scale.coords()[0],
int(x.label.place_info()['x'])) int(x.label.place_info()['x']))
# value outside range # value outside range
x.value = x.scale['to'] + 1 # no changes shouldn't happen x.value = x.scale['to'] + 1 # no changes shouldn't happen
x.update() x.update()
self.failUnlessEqual(x.label['text'], newval) self.assertEqual(x.label['text'], newval)
self.failUnlessEqual(x.scale.coords()[0], self.assertEqual(x.scale.coords()[0],
int(x.label.place_info()['x'])) int(x.label.place_info()['x']))
x.destroy() x.destroy()
@ -172,7 +172,7 @@ class LabeledScaleTest(unittest.TestCase):
x.value = 3 x.value = 3
x.update() x.update()
x.master.wm_geometry("%dx%d" % (width_new, height_new)) x.master.wm_geometry("%dx%d" % (width_new, height_new))
self.failUnlessEqual(int(x.label.place_info()['x']), self.assertEqual(int(x.label.place_info()['x']),
x.scale.coords()[0]) x.scale.coords()[0])
# Reset geometry # Reset geometry
@ -197,20 +197,20 @@ class OptionMenuTest(unittest.TestCase):
name = var._name name = var._name
optmenu.update_idletasks() optmenu.update_idletasks()
optmenu.destroy() optmenu.destroy()
self.failUnlessEqual(optmenu.tk.globalgetvar(name), var.get()) self.assertEqual(optmenu.tk.globalgetvar(name), var.get())
del var del var
self.failUnlessRaises(Tkinter.TclError, optmenu.tk.globalgetvar, name) self.assertRaises(Tkinter.TclError, optmenu.tk.globalgetvar, name)
def test_initialization(self): def test_initialization(self):
self.failUnlessRaises(Tkinter.TclError, self.assertRaises(Tkinter.TclError,
ttk.OptionMenu, None, self.textvar, invalid='thing') ttk.OptionMenu, None, self.textvar, invalid='thing')
optmenu = ttk.OptionMenu(None, self.textvar, 'b', 'a', 'b') optmenu = ttk.OptionMenu(None, self.textvar, 'b', 'a', 'b')
self.failUnlessEqual(optmenu._variable.get(), 'b') self.assertEqual(optmenu._variable.get(), 'b')
self.failUnless(optmenu['menu']) self.assertTrue(optmenu['menu'])
self.failUnless(optmenu['textvariable']) self.assertTrue(optmenu['textvariable'])
optmenu.destroy() optmenu.destroy()
@ -222,10 +222,10 @@ class OptionMenuTest(unittest.TestCase):
found_default = False found_default = False
for i in range(len(items)): for i in range(len(items)):
value = optmenu['menu'].entrycget(i, 'value') value = optmenu['menu'].entrycget(i, 'value')
self.failUnlessEqual(value, items[i]) self.assertEqual(value, items[i])
if value == default: if value == default:
found_default = True found_default = True
self.failUnless(found_default) self.assertTrue(found_default)
optmenu.destroy() optmenu.destroy()
# default shouldn't be in menu if it is not part of values # default shouldn't be in menu if it is not part of values
@ -238,26 +238,26 @@ class OptionMenuTest(unittest.TestCase):
if last == curr: if last == curr:
# no more menu entries # no more menu entries
break break
self.failIf(curr == default) self.assertFalse(curr == default)
i += 1 i += 1
self.failUnlessEqual(i, len(items)) self.assertEqual(i, len(items))
# check that variable is updated correctly # check that variable is updated correctly
optmenu.pack() optmenu.pack()
optmenu.wait_visibility() optmenu.wait_visibility()
optmenu['menu'].invoke(0) optmenu['menu'].invoke(0)
self.failUnlessEqual(optmenu._variable.get(), items[0]) self.assertEqual(optmenu._variable.get(), items[0])
# changing to an invalid index shouldn't change the variable # changing to an invalid index shouldn't change the variable
self.failUnlessRaises(Tkinter.TclError, optmenu['menu'].invoke, -1) self.assertRaises(Tkinter.TclError, optmenu['menu'].invoke, -1)
self.failUnlessEqual(optmenu._variable.get(), items[0]) self.assertEqual(optmenu._variable.get(), items[0])
optmenu.destroy() optmenu.destroy()
# specifying a callback # specifying a callback
success = [] success = []
def cb_test(item): def cb_test(item):
self.failUnlessEqual(item, items[1]) self.assertEqual(item, items[1])
success.append(True) success.append(True)
optmenu = ttk.OptionMenu(None, self.textvar, 'a', command=cb_test, optmenu = ttk.OptionMenu(None, self.textvar, 'a', command=cb_test,
*items) *items)

158
Lib/lib-tk/test/test_ttk/test_functions.py
View file

@ -28,12 +28,12 @@ class InternalFunctionsTest(unittest.TestCase):
def test_format_optdict(self): def test_format_optdict(self):
def check_against(fmt_opts, result): def check_against(fmt_opts, result):
for i in range(0, len(fmt_opts), 2): for i in range(0, len(fmt_opts), 2):
self.failUnlessEqual(result.pop(fmt_opts[i]), fmt_opts[i + 1]) self.assertEqual(result.pop(fmt_opts[i]), fmt_opts[i + 1])
if result: if result:
self.fail("result still got elements: %s" % result) self.fail("result still got elements: %s" % result)
# passing an empty dict should return an empty object (tuple here) # passing an empty dict should return an empty object (tuple here)
self.failIf(ttk._format_optdict({})) self.assertFalse(ttk._format_optdict({}))
# check list formatting # check list formatting
check_against( check_against(
@ -63,7 +63,7 @@ class InternalFunctionsTest(unittest.TestCase):
# check if giving unicode keys is fine # check if giving unicode keys is fine
check_against(ttk._format_optdict(opts), {u'-αβγ': True, u'-á': False}) check_against(ttk._format_optdict(opts), {u'-αβγ': True, u'-á': False})
# opts should remain unchanged # opts should remain unchanged
self.failUnlessEqual(opts, orig_opts) self.assertEqual(opts, orig_opts)
# passing values with spaces inside a tuple/list # passing values with spaces inside a tuple/list
check_against( check_against(
@ -73,113 +73,113 @@ class InternalFunctionsTest(unittest.TestCase):
# ignore an option # ignore an option
amount_opts = len(ttk._format_optdict(opts, ignore=(u'á'))) / 2 amount_opts = len(ttk._format_optdict(opts, ignore=(u'á'))) / 2
self.failUnlessEqual(amount_opts, len(opts) - 1) self.assertEqual(amount_opts, len(opts) - 1)
# ignore non-existing options # ignore non-existing options
amount_opts = len(ttk._format_optdict(opts, ignore=(u'á', 'b'))) / 2 amount_opts = len(ttk._format_optdict(opts, ignore=(u'á', 'b'))) / 2
self.failUnlessEqual(amount_opts, len(opts) - 1) self.assertEqual(amount_opts, len(opts) - 1)
# ignore every option # ignore every option
self.failIf(ttk._format_optdict(opts, ignore=opts.keys())) self.assertFalse(ttk._format_optdict(opts, ignore=opts.keys()))
def test_format_mapdict(self): def test_format_mapdict(self):
opts = {'a': [('b', 'c', 'val'), ('d', 'otherval'), ('', 'single')]} opts = {'a': [('b', 'c', 'val'), ('d', 'otherval'), ('', 'single')]}
result = ttk._format_mapdict(opts) result = ttk._format_mapdict(opts)
self.failUnlessEqual(len(result), len(opts.keys()) * 2) self.assertEqual(len(result), len(opts.keys()) * 2)
self.failUnlessEqual(result, ('-a', '{b c} val d otherval {} single')) self.assertEqual(result, ('-a', '{b c} val d otherval {} single'))
self.failUnlessEqual(ttk._format_mapdict(opts, script=True), self.assertEqual(ttk._format_mapdict(opts, script=True),
('-a', '{{b c} val d otherval {} single}')) ('-a', '{{b c} val d otherval {} single}'))
self.failUnlessEqual(ttk._format_mapdict({2: []}), ('-2', '')) self.assertEqual(ttk._format_mapdict({2: []}), ('-2', ''))
opts = {u'üñíćódè': [(u'á', u'vãl')]} opts = {u'üñíćódè': [(u'á', u'vãl')]}
result = ttk._format_mapdict(opts) result = ttk._format_mapdict(opts)
self.failUnlessEqual(result, (u'-üñíćódè', u'á vãl')) self.assertEqual(result, (u'-üñíćódè', u'á vãl'))
# empty states # empty states
valid = {'opt': [('', u'', 'hi')]} valid = {'opt': [('', u'', 'hi')]}
self.failUnlessEqual(ttk._format_mapdict(valid), ('-opt', '{ } hi')) self.assertEqual(ttk._format_mapdict(valid), ('-opt', '{ } hi'))
# when passing multiple states, they all must be strings # when passing multiple states, they all must be strings
invalid = {'opt': [(1, 2, 'valid val')]} invalid = {'opt': [(1, 2, 'valid val')]}
self.failUnlessRaises(TypeError, ttk._format_mapdict, invalid) self.assertRaises(TypeError, ttk._format_mapdict, invalid)
invalid = {'opt': [([1], '2', 'valid val')]} invalid = {'opt': [([1], '2', 'valid val')]}
self.failUnlessRaises(TypeError, ttk._format_mapdict, invalid) self.assertRaises(TypeError, ttk._format_mapdict, invalid)
# but when passing a single state, it can be anything # but when passing a single state, it can be anything
valid = {'opt': [[1, 'value']]} valid = {'opt': [[1, 'value']]}
self.failUnlessEqual(ttk._format_mapdict(valid), ('-opt', '1 value')) self.assertEqual(ttk._format_mapdict(valid), ('-opt', '1 value'))
# special attention to single states which evalute to False # special attention to single states which evalute to False
for stateval in (None, 0, False, '', set()): # just some samples for stateval in (None, 0, False, '', set()): # just some samples
valid = {'opt': [(stateval, 'value')]} valid = {'opt': [(stateval, 'value')]}
self.failUnlessEqual(ttk._format_mapdict(valid), self.assertEqual(ttk._format_mapdict(valid),
('-opt', '{} value')) ('-opt', '{} value'))
# values must be iterable # values must be iterable
opts = {'a': None} opts = {'a': None}
self.failUnlessRaises(TypeError, ttk._format_mapdict, opts) self.assertRaises(TypeError, ttk._format_mapdict, opts)
# items in the value must have size >= 2 # items in the value must have size >= 2
self.failUnlessRaises(IndexError, ttk._format_mapdict, self.assertRaises(IndexError, ttk._format_mapdict,
{'a': [('invalid', )]}) {'a': [('invalid', )]})
def test_format_elemcreate(self): def test_format_elemcreate(self):
self.failUnless(ttk._format_elemcreate(None), (None, ())) self.assertTrue(ttk._format_elemcreate(None), (None, ()))
## Testing type = image ## Testing type = image
# image type expects at least an image name, so this should raise # image type expects at least an image name, so this should raise
# IndexError since it tries to access the index 0 of an empty tuple # IndexError since it tries to access the index 0 of an empty tuple
self.failUnlessRaises(IndexError, ttk._format_elemcreate, 'image') self.assertRaises(IndexError, ttk._format_elemcreate, 'image')
# don't format returned values as a tcl script # don't format returned values as a tcl script
# minimum acceptable for image type # minimum acceptable for image type
self.failUnlessEqual(ttk._format_elemcreate('image', False, 'test'), self.assertEqual(ttk._format_elemcreate('image', False, 'test'),
("test ", ())) ("test ", ()))
# specifiyng a state spec # specifiyng a state spec
self.failUnlessEqual(ttk._format_elemcreate('image', False, 'test', self.assertEqual(ttk._format_elemcreate('image', False, 'test',
('', 'a')), ("test {} a", ())) ('', 'a')), ("test {} a", ()))
# state spec with multiple states # state spec with multiple states
self.failUnlessEqual(ttk._format_elemcreate('image', False, 'test', self.assertEqual(ttk._format_elemcreate('image', False, 'test',
('a', 'b', 'c')), ("test {a b} c", ())) ('a', 'b', 'c')), ("test {a b} c", ()))
# state spec and options # state spec and options
self.failUnlessEqual(ttk._format_elemcreate('image', False, 'test', self.assertEqual(ttk._format_elemcreate('image', False, 'test',
('a', 'b'), a='x', b='y'), ("test a b", ("-a", "x", "-b", "y"))) ('a', 'b'), a='x', b='y'), ("test a b", ("-a", "x", "-b", "y")))
# format returned values as a tcl script # format returned values as a tcl script
# state spec with multiple states and an option with a multivalue # state spec with multiple states and an option with a multivalue
self.failUnlessEqual(ttk._format_elemcreate('image', True, 'test', self.assertEqual(ttk._format_elemcreate('image', True, 'test',
('a', 'b', 'c', 'd'), x=[2, 3]), ("{test {a b c} d}", "-x {2 3}")) ('a', 'b', 'c', 'd'), x=[2, 3]), ("{test {a b c} d}", "-x {2 3}"))
## Testing type = vsapi ## Testing type = vsapi
# vsapi type expects at least a class name and a part_id, so this # vsapi type expects at least a class name and a part_id, so this
# should raise an ValueError since it tries to get two elements from # should raise an ValueError since it tries to get two elements from
# an empty tuple # an empty tuple
self.failUnlessRaises(ValueError, ttk._format_elemcreate, 'vsapi') self.assertRaises(ValueError, ttk._format_elemcreate, 'vsapi')
# don't format returned values as a tcl script # don't format returned values as a tcl script
# minimum acceptable for vsapi # minimum acceptable for vsapi
self.failUnlessEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b'), self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b'),
("a b ", ())) ("a b ", ()))
# now with a state spec with multiple states # now with a state spec with multiple states
self.failUnlessEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b', self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
('a', 'b', 'c')), ("a b {a b} c", ())) ('a', 'b', 'c')), ("a b {a b} c", ()))
# state spec and option # state spec and option
self.failUnlessEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b', self.assertEqual(ttk._format_elemcreate('vsapi', False, 'a', 'b',
('a', 'b'), opt='x'), ("a b a b", ("-opt", "x"))) ('a', 'b'), opt='x'), ("a b a b", ("-opt", "x")))
# format returned values as a tcl script # format returned values as a tcl script
# state spec with a multivalue and an option # state spec with a multivalue and an option
self.failUnlessEqual(ttk._format_elemcreate('vsapi', True, 'a', 'b', self.assertEqual(ttk._format_elemcreate('vsapi', True, 'a', 'b',
('a', 'b', [1, 2]), opt='x'), ("{a b {a b} {1 2}}", "-opt x")) ('a', 'b', [1, 2]), opt='x'), ("{a b {a b} {1 2}}", "-opt x"))
# Testing type = from # Testing type = from
# from type expects at least a type name # from type expects at least a type name
self.failUnlessRaises(IndexError, ttk._format_elemcreate, 'from') self.assertRaises(IndexError, ttk._format_elemcreate, 'from')
self.failUnlessEqual(ttk._format_elemcreate('from', False, 'a'), self.assertEqual(ttk._format_elemcreate('from', False, 'a'),
('a', ())) ('a', ()))
self.failUnlessEqual(ttk._format_elemcreate('from', False, 'a', 'b'), self.assertEqual(ttk._format_elemcreate('from', False, 'a', 'b'),
('a', ('b', ))) ('a', ('b', )))
self.failUnlessEqual(ttk._format_elemcreate('from', True, 'a', 'b'), self.assertEqual(ttk._format_elemcreate('from', True, 'a', 'b'),
('{a}', 'b')) ('{a}', 'b'))
@ -208,75 +208,75 @@ class InternalFunctionsTest(unittest.TestCase):
spaces(2 * indent_size), spaces(indent_size), spaces())) spaces(2 * indent_size), spaces(indent_size), spaces()))
# empty layout # empty layout
self.failUnlessEqual(ttk._format_layoutlist([])[0], '') self.assertEqual(ttk._format_layoutlist([])[0], '')
# smallest (after an empty one) acceptable layout # smallest (after an empty one) acceptable layout
smallest = ttk._format_layoutlist([('a', None)], indent=0) smallest = ttk._format_layoutlist([('a', None)], indent=0)
self.failUnlessEqual(smallest, self.assertEqual(smallest,
ttk._format_layoutlist([('a', '')], indent=0)) ttk._format_layoutlist([('a', '')], indent=0))
self.failUnlessEqual(smallest[0], 'a') self.assertEqual(smallest[0], 'a')
# testing indentation levels # testing indentation levels
self.failUnlessEqual(sample(), sample_expected()) self.assertEqual(sample(), sample_expected())
for i in range(4): for i in range(4):
self.failUnlessEqual(sample(i), sample_expected(i)) self.assertEqual(sample(i), sample_expected(i))
self.failUnlessEqual(sample(i, i), sample_expected(i, i)) self.assertEqual(sample(i, i), sample_expected(i, i))
# invalid layout format, different kind of exceptions will be # invalid layout format, different kind of exceptions will be
# raised # raised
# plain wrong format # plain wrong format
self.failUnlessRaises(ValueError, ttk._format_layoutlist, self.assertRaises(ValueError, ttk._format_layoutlist,
['bad', 'format']) ['bad', 'format'])
self.failUnlessRaises(TypeError, ttk._format_layoutlist, None) self.assertRaises(TypeError, ttk._format_layoutlist, None)
# _format_layoutlist always expects the second item (in every item) # _format_layoutlist always expects the second item (in every item)
# to act like a dict (except when the value evalutes to False). # to act like a dict (except when the value evalutes to False).
self.failUnlessRaises(AttributeError, self.assertRaises(AttributeError,
ttk._format_layoutlist, [('a', 'b')]) ttk._format_layoutlist, [('a', 'b')])
# bad children formatting # bad children formatting
self.failUnlessRaises(ValueError, ttk._format_layoutlist, self.assertRaises(ValueError, ttk._format_layoutlist,
[('name', {'children': {'a': None}})]) [('name', {'children': {'a': None}})])
def test_script_from_settings(self): def test_script_from_settings(self):
# empty options # empty options
self.failIf(ttk._script_from_settings({'name': self.assertFalse(ttk._script_from_settings({'name':
{'configure': None, 'map': None, 'element create': None}})) {'configure': None, 'map': None, 'element create': None}}))
# empty layout # empty layout
self.failUnlessEqual( self.assertEqual(
ttk._script_from_settings({'name': {'layout': None}}), ttk._script_from_settings({'name': {'layout': None}}),
"ttk::style layout name {\nnull\n}") "ttk::style layout name {\nnull\n}")
configdict = {u'αβγ': True, u'á': False} configdict = {u'αβγ': True, u'á': False}
self.failUnless( self.assertTrue(
ttk._script_from_settings({'name': {'configure': configdict}})) ttk._script_from_settings({'name': {'configure': configdict}}))
mapdict = {u'üñíćódè': [(u'á', u'vãl')]} mapdict = {u'üñíćódè': [(u'á', u'vãl')]}
self.failUnless( self.assertTrue(
ttk._script_from_settings({'name': {'map': mapdict}})) ttk._script_from_settings({'name': {'map': mapdict}}))
# invalid image element # invalid image element
self.failUnlessRaises(IndexError, self.assertRaises(IndexError,
ttk._script_from_settings, {'name': {'element create': ['image']}}) ttk._script_from_settings, {'name': {'element create': ['image']}})
# minimal valid image # minimal valid image
self.failUnless(ttk._script_from_settings({'name': self.assertTrue(ttk._script_from_settings({'name':
{'element create': ['image', 'name']}})) {'element create': ['image', 'name']}}))
image = {'thing': {'element create': image = {'thing': {'element create':
['image', 'name', ('state1', 'state2', 'val')]}} ['image', 'name', ('state1', 'state2', 'val')]}}
self.failUnlessEqual(ttk._script_from_settings(image), self.assertEqual(ttk._script_from_settings(image),
"ttk::style element create thing image {name {state1 state2} val} ") "ttk::style element create thing image {name {state1 state2} val} ")
image['thing']['element create'].append({'opt': 30}) image['thing']['element create'].append({'opt': 30})
self.failUnlessEqual(ttk._script_from_settings(image), self.assertEqual(ttk._script_from_settings(image),
"ttk::style element create thing image {name {state1 state2} val} " "ttk::style element create thing image {name {state1 state2} val} "
"-opt 30") "-opt 30")
image['thing']['element create'][-1]['opt'] = [MockTclObj(3), image['thing']['element create'][-1]['opt'] = [MockTclObj(3),
MockTclObj('2m')] MockTclObj('2m')]
self.failUnlessEqual(ttk._script_from_settings(image), self.assertEqual(ttk._script_from_settings(image),
"ttk::style element create thing image {name {state1 state2} val} " "ttk::style element create thing image {name {state1 state2} val} "
"-opt {3 2m}") "-opt {3 2m}")
@ -284,28 +284,28 @@ class InternalFunctionsTest(unittest.TestCase):
def test_dict_from_tcltuple(self): def test_dict_from_tcltuple(self):
fakettuple = ('-a', '{1 2 3}', '-something', 'foo') fakettuple = ('-a', '{1 2 3}', '-something', 'foo')
self.failUnlessEqual(ttk._dict_from_tcltuple(fakettuple, False), self.assertEqual(ttk._dict_from_tcltuple(fakettuple, False),
{'-a': '{1 2 3}', '-something': 'foo'}) {'-a': '{1 2 3}', '-something': 'foo'})
self.failUnlessEqual(ttk._dict_from_tcltuple(fakettuple), self.assertEqual(ttk._dict_from_tcltuple(fakettuple),
{'a': '{1 2 3}', 'something': 'foo'}) {'a': '{1 2 3}', 'something': 'foo'})
# passing a tuple with a single item should return an empty dict, # passing a tuple with a single item should return an empty dict,
# since it tries to break the tuple by pairs. # since it tries to break the tuple by pairs.
self.failIf(ttk._dict_from_tcltuple(('single', ))) self.assertFalse(ttk._dict_from_tcltuple(('single', )))
sspec = MockStateSpec('a', 'b') sspec = MockStateSpec('a', 'b')
self.failUnlessEqual(ttk._dict_from_tcltuple(('-a', (sspec, 'val'))), self.assertEqual(ttk._dict_from_tcltuple(('-a', (sspec, 'val'))),
{'a': [('a', 'b', 'val')]}) {'a': [('a', 'b', 'val')]})
self.failUnlessEqual(ttk._dict_from_tcltuple((MockTclObj('-padding'), self.assertEqual(ttk._dict_from_tcltuple((MockTclObj('-padding'),
[MockTclObj('1'), 2, MockTclObj('3m')])), [MockTclObj('1'), 2, MockTclObj('3m')])),
{'padding': [1, 2, '3m']}) {'padding': [1, 2, '3m']})
def test_list_from_statespec(self): def test_list_from_statespec(self):
def test_it(sspec, value, res_value, states): def test_it(sspec, value, res_value, states):
self.failUnlessEqual(ttk._list_from_statespec( self.assertEqual(ttk._list_from_statespec(
(sspec, value)), [states + (res_value, )]) (sspec, value)), [states + (res_value, )])
states_even = tuple('state%d' % i for i in range(6)) states_even = tuple('state%d' % i for i in range(6))
@ -322,19 +322,19 @@ class InternalFunctionsTest(unittest.TestCase):
def test_list_from_layouttuple(self): def test_list_from_layouttuple(self):
# empty layout tuple # empty layout tuple
self.failIf(ttk._list_from_layouttuple(())) self.assertFalse(ttk._list_from_layouttuple(()))
# shortest layout tuple # shortest layout tuple
self.failUnlessEqual(ttk._list_from_layouttuple(('name', )), self.assertEqual(ttk._list_from_layouttuple(('name', )),
[('name', {})]) [('name', {})])
# not so interesting ltuple # not so interesting ltuple
sample_ltuple = ('name', '-option', 'value') sample_ltuple = ('name', '-option', 'value')
self.failUnlessEqual(ttk._list_from_layouttuple(sample_ltuple), self.assertEqual(ttk._list_from_layouttuple(sample_ltuple),
[('name', {'option': 'value'})]) [('name', {'option': 'value'})])
# empty children # empty children
self.failUnlessEqual(ttk._list_from_layouttuple( self.assertEqual(ttk._list_from_layouttuple(
('something', '-children', ())), ('something', '-children', ())),
[('something', {'children': []})] [('something', {'children': []})]
) )
@ -347,7 +347,7 @@ class InternalFunctionsTest(unittest.TestCase):
) )
) )
) )
self.failUnlessEqual(ttk._list_from_layouttuple(ltuple), self.assertEqual(ttk._list_from_layouttuple(ltuple),
[('name', {'option': 'niceone', 'children': [('name', {'option': 'niceone', 'children':
[('otherone', {'otheropt': 'othervalue', 'children': [('otherone', {'otheropt': 'othervalue', 'children':
[('child', {})] [('child', {})]
@ -356,13 +356,13 @@ class InternalFunctionsTest(unittest.TestCase):
) )
# bad tuples # bad tuples
self.failUnlessRaises(ValueError, ttk._list_from_layouttuple, self.assertRaises(ValueError, ttk._list_from_layouttuple,
('name', 'no_minus')) ('name', 'no_minus'))
self.failUnlessRaises(ValueError, ttk._list_from_layouttuple, self.assertRaises(ValueError, ttk._list_from_layouttuple,
('name', 'no_minus', 'value')) ('name', 'no_minus', 'value'))
self.failUnlessRaises(ValueError, ttk._list_from_layouttuple, self.assertRaises(ValueError, ttk._list_from_layouttuple,
('something', '-children')) # no children ('something', '-children')) # no children
self.failUnlessRaises(ValueError, ttk._list_from_layouttuple, self.assertRaises(ValueError, ttk._list_from_layouttuple,
('something', '-children', 'value')) # invalid children ('something', '-children', 'value')) # invalid children
@ -373,10 +373,10 @@ class InternalFunctionsTest(unittest.TestCase):
return (opt, val) return (opt, val)
options = {'test': None} options = {'test': None}
self.failUnlessEqual(ttk._val_or_dict(options, func), "test val") self.assertEqual(ttk._val_or_dict(options, func), "test val")
options = {'test': 3} options = {'test': 3}
self.failUnlessEqual(ttk._val_or_dict(options, func), options) self.assertEqual(ttk._val_or_dict(options, func), options)
def test_convert_stringval(self): def test_convert_stringval(self):
@ -385,10 +385,10 @@ class InternalFunctionsTest(unittest.TestCase):
(None, 'None') (None, 'None')
) )
for orig, expected in tests: for orig, expected in tests:
self.failUnlessEqual(ttk._convert_stringval(orig), expected) self.assertEqual(ttk._convert_stringval(orig), expected)
if sys.getdefaultencoding() == 'ascii': if sys.getdefaultencoding() == 'ascii':
self.failUnlessRaises(UnicodeDecodeError, self.assertRaises(UnicodeDecodeError,
ttk._convert_stringval, 'á') ttk._convert_stringval, 'á')
@ -396,27 +396,27 @@ class TclObjsToPyTest(unittest.TestCase):
def test_unicode(self): def test_unicode(self):
adict = {'opt': u'välúè'} adict = {'opt': u'välúè'}
self.failUnlessEqual(ttk.tclobjs_to_py(adict), {'opt': u'välúè'}) self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': u'välúè'})
adict['opt'] = MockTclObj(adict['opt']) adict['opt'] = MockTclObj(adict['opt'])
self.failUnlessEqual(ttk.tclobjs_to_py(adict), {'opt': u'välúè'}) self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': u'välúè'})
def test_multivalues(self): def test_multivalues(self):
adict = {'opt': [1, 2, 3, 4]} adict = {'opt': [1, 2, 3, 4]}
self.failUnlessEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 2, 3, 4]}) self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 2, 3, 4]})
adict['opt'] = [1, 'xm', 3] adict['opt'] = [1, 'xm', 3]
self.failUnlessEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 'xm', 3]}) self.assertEqual(ttk.tclobjs_to_py(adict), {'opt': [1, 'xm', 3]})
adict['opt'] = (MockStateSpec('a', 'b'), u'válũè') adict['opt'] = (MockStateSpec('a', 'b'), u'válũè')
self.failUnlessEqual(ttk.tclobjs_to_py(adict), self.assertEqual(ttk.tclobjs_to_py(adict),
{'opt': [('a', 'b', u'válũè')]}) {'opt': [('a', 'b', u'válũè')]})
self.failUnlessEqual(ttk.tclobjs_to_py({'x': ['y z']}), self.assertEqual(ttk.tclobjs_to_py({'x': ['y z']}),
{'x': ['y z']}) {'x': ['y z']})
def test_nosplit(self): def test_nosplit(self):
self.failUnlessEqual(ttk.tclobjs_to_py({'text': 'some text'}), self.assertEqual(ttk.tclobjs_to_py({'text': 'some text'}),
{'text': 'some text'}) {'text': 'some text'})
tests_nogui = (InternalFunctionsTest, TclObjsToPyTest) tests_nogui = (InternalFunctionsTest, TclObjsToPyTest)

30
Lib/lib-tk/test/test_ttk/test_style.py
View file

@ -16,17 +16,17 @@ class StyleTest(unittest.TestCase):
def test_configure(self): def test_configure(self):
style = self.style style = self.style
style.configure('TButton', background='yellow') style.configure('TButton', background='yellow')
self.failUnlessEqual(style.configure('TButton', 'background'), self.assertEqual(style.configure('TButton', 'background'),
'yellow') 'yellow')
self.failUnless(isinstance(style.configure('TButton'), dict)) self.assertTrue(isinstance(style.configure('TButton'), dict))
def test_map(self): def test_map(self):
style = self.style style = self.style
style.map('TButton', background=[('active', 'background', 'blue')]) style.map('TButton', background=[('active', 'background', 'blue')])
self.failUnlessEqual(style.map('TButton', 'background'), self.assertEqual(style.map('TButton', 'background'),
[('active', 'background', 'blue')]) [('active', 'background', 'blue')])
self.failUnless(isinstance(style.map('TButton'), dict)) self.assertTrue(isinstance(style.map('TButton'), dict))
def test_lookup(self): def test_lookup(self):
@ -34,38 +34,38 @@ class StyleTest(unittest.TestCase):
style.configure('TButton', background='yellow') style.configure('TButton', background='yellow')
style.map('TButton', background=[('active', 'background', 'blue')]) style.map('TButton', background=[('active', 'background', 'blue')])
self.failUnlessEqual(style.lookup('TButton', 'background'), 'yellow') self.assertEqual(style.lookup('TButton', 'background'), 'yellow')
self.failUnlessEqual(style.lookup('TButton', 'background', self.assertEqual(style.lookup('TButton', 'background',
['active', 'background']), 'blue') ['active', 'background']), 'blue')
self.failUnlessEqual(style.lookup('TButton', 'optionnotdefined', self.assertEqual(style.lookup('TButton', 'optionnotdefined',
default='iknewit'), 'iknewit') default='iknewit'), 'iknewit')
def test_layout(self): def test_layout(self):
style = self.style style = self.style
self.failUnlessRaises(Tkinter.TclError, style.layout, 'NotALayout') self.assertRaises(Tkinter.TclError, style.layout, 'NotALayout')
tv_style = style.layout('Treeview') tv_style = style.layout('Treeview')
# "erase" Treeview layout # "erase" Treeview layout
style.layout('Treeview', '') style.layout('Treeview', '')
self.failUnlessEqual(style.layout('Treeview'), self.assertEqual(style.layout('Treeview'),
[('null', {'sticky': 'nswe'})] [('null', {'sticky': 'nswe'})]
) )
# restore layout # restore layout
style.layout('Treeview', tv_style) style.layout('Treeview', tv_style)
self.failUnlessEqual(style.layout('Treeview'), tv_style) self.assertEqual(style.layout('Treeview'), tv_style)
# should return a list # should return a list
self.failUnless(isinstance(style.layout('TButton'), list)) self.assertTrue(isinstance(style.layout('TButton'), list))
# correct layout, but "option" doesn't exist as option # correct layout, but "option" doesn't exist as option
self.failUnlessRaises(Tkinter.TclError, style.layout, 'Treeview', self.assertRaises(Tkinter.TclError, style.layout, 'Treeview',
[('name', {'option': 'inexistent'})]) [('name', {'option': 'inexistent'})])
def test_theme_use(self): def test_theme_use(self):
self.failUnlessRaises(Tkinter.TclError, self.style.theme_use, self.assertRaises(Tkinter.TclError, self.style.theme_use,
'nonexistingname') 'nonexistingname')
curr_theme = self.style.theme_use() curr_theme = self.style.theme_use()
@ -79,8 +79,8 @@ class StyleTest(unittest.TestCase):
# just one theme available, can't go on with tests # just one theme available, can't go on with tests
return return
self.failIf(curr_theme == new_theme) self.assertFalse(curr_theme == new_theme)
self.failIf(new_theme != self.style.theme_use()) self.assertFalse(new_theme != self.style.theme_use())
self.style.theme_use(curr_theme) self.style.theme_use(curr_theme)

560
Lib/lib-tk/test/test_ttk/test_widgets.py
View file

File diff suppressed because it is too large Load diff

102
Lib/test/mapping_tests.py
View file

@ -50,17 +50,17 @@ class BasicTestMappingProtocol(unittest.TestCase):
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 = self.other.keys()[0] knownkey = 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))
#has_key #has_key
for k in self.reference: for k in self.reference:
self.assert_(d.has_key(k)) self.assertTrue(d.has_key(k))
self.assert_(k in d) self.assertTrue(k in d)
for k in self.other: for k in self.other:
self.failIf(d.has_key(k)) self.assertFalse(d.has_key(k))
self.failIf(k in d) self.assertFalse(k in d)
#cmp #cmp
self.assertEqual(cmp(p,p), 0) self.assertEqual(cmp(p,p), 0)
self.assertEqual(cmp(d,d), 0) self.assertEqual(cmp(d,d), 0)
@ -71,10 +71,10 @@ class BasicTestMappingProtocol(unittest.TestCase):
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(d.iterkeys(), d.keys(), self.reference.keys()) check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
check_iterandlist(iter(d), d.keys(), self.reference.keys()) check_iterandlist(iter(d), d.keys(), self.reference.keys())
check_iterandlist(d.itervalues(), d.values(), self.reference.values()) check_iterandlist(d.itervalues(), d.values(), self.reference.values())
@ -84,7 +84,7 @@ class BasicTestMappingProtocol(unittest.TestCase):
knownkey, knownvalue = self.other.iteritems().next() knownkey, knownvalue = self.other.iteritems().next()
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
@ -95,7 +95,7 @@ class BasicTestMappingProtocol(unittest.TestCase):
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)
@ -114,16 +114,16 @@ class BasicTestMappingProtocol(unittest.TestCase):
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)
@ -132,17 +132,17 @@ class BasicTestMappingProtocol(unittest.TestCase):
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(d.keys(), []) self.assertEqual(d.keys(), [])
d = self.reference d = self.reference
self.assert_(self.inmapping.keys()[0] in d.keys()) self.assertTrue(self.inmapping.keys()[0] in d.keys())
self.assert_(self.other.keys()[0] not in d.keys()) self.assertTrue(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 @@ class BasicTestMappingProtocol(unittest.TestCase):
def test_get(self): def test_get(self):
d = self._empty_mapping() d = self._empty_mapping()
self.assert_(d.get(self.other.keys()[0]) is None) self.assertTrue(d.get(self.other.keys()[0]) is None)
self.assertEqual(d.get(self.other.keys()[0], 3), 3) self.assertEqual(d.get(self.other.keys()[0], 3), 3)
d = self.reference d = self.reference
self.assert_(d.get(self.other.keys()[0]) is None) self.assertTrue(d.get(self.other.keys()[0]) is None)
self.assertEqual(d.get(self.other.keys()[0], 3), 3) self.assertEqual(d.get(self.other.keys()[0], 3), 3)
self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0]) self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0])
self.assertEqual(d.get(self.inmapping.keys()[0], 3), self.inmapping.values()[0]) self.assertEqual(d.get(self.inmapping.keys()[0], 3), self.inmapping.values()[0])
@ -302,15 +302,15 @@ class BasicTestMappingProtocol(unittest.TestCase):
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)
@ -318,9 +318,9 @@ class TestMappingProtocol(BasicTestMappingProtocol):
self.assertEqual(d.keys(), []) self.assertEqual(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)
@ -335,7 +335,7 @@ class TestMappingProtocol(BasicTestMappingProtocol):
def test_has_key(self): def test_has_key(self):
d = self._empty_mapping() d = self._empty_mapping()
self.assert_(not d.has_key('a')) self.assertTrue(not d.has_key('a'))
d = self._full_mapping({'a': 1, 'b': 2}) d = self._full_mapping({'a': 1, 'b': 2})
k = d.keys() k = d.keys()
k.sort() k.sort()
@ -345,12 +345,12 @@ class TestMappingProtocol(BasicTestMappingProtocol):
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__)
@ -429,7 +429,7 @@ class TestMappingProtocol(BasicTestMappingProtocol):
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([]), {})
@ -440,17 +440,17 @@ class TestMappingProtocol(BasicTestMappingProtocol):
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 UserDict.UserDict() return UserDict.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, UserDict.UserDict)) # self.assertTrue(isinstance(ud, UserDict.UserDict))
self.assertRaises(TypeError, dict.fromkeys) self.assertRaises(TypeError, dict.fromkeys)
class Exc(Exception): pass class Exc(Exception): pass
@ -480,16 +480,16 @@ class TestMappingProtocol(BasicTestMappingProtocol):
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)
@ -497,9 +497,9 @@ class TestMappingProtocol(BasicTestMappingProtocol):
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)
@ -525,9 +525,9 @@ class TestMappingProtocol(BasicTestMappingProtocol):
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)
@ -585,7 +585,7 @@ class TestHashMappingProtocol(TestMappingProtocol):
return UserDict.UserDict() return UserDict.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, UserDict.UserDict)) self.assertTrue(isinstance(ud, UserDict.UserDict))
def test_pop(self): def test_pop(self):
TestMappingProtocol.test_pop(self) TestMappingProtocol.test_pop(self)
@ -636,8 +636,8 @@ class TestHashMappingProtocol(TestMappingProtocol):
self.assertRaises(Exc, repr, d) self.assertRaises(Exc, repr, d)
def test_le(self): def test_le(self):
self.assert_(not (self._empty_mapping() < self._empty_mapping())) self.assertTrue(not (self._empty_mapping() < self._empty_mapping()))
self.assert_(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L}))) self.assertTrue(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L})))
class Exc(Exception): pass class Exc(Exception): pass

26
Lib/test/pickletester.py
View file

@ -461,7 +461,7 @@ class AbstractPickleTests(unittest.TestCase):
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 = ([],)
@ -471,7 +471,7 @@ class AbstractPickleTests(unittest.TestCase):
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 = {}
@ -480,7 +480,7 @@ class AbstractPickleTests(unittest.TestCase):
s = self.dumps(d, proto) s = self.dumps(d, proto)
x = self.loads(s) x = self.loads(s)
self.assertEqual(x.keys(), [1]) self.assertEqual(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()
@ -489,7 +489,7 @@ class AbstractPickleTests(unittest.TestCase):
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 = []
@ -503,7 +503,7 @@ class AbstractPickleTests(unittest.TestCase):
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(x[0].attr.keys(), [1]) self.assertEqual(x[0].attr.keys(), [1])
self.assert_(x[0].attr[1] is x) self.assertTrue(x[0].attr[1] is x)
def test_garyp(self): def test_garyp(self):
self.assertRaises(self.error, self.loads, 'garyp') self.assertRaises(self.error, self.loads, 'garyp')
@ -644,7 +644,7 @@ class AbstractPickleTests(unittest.TestCase):
try: try:
self.loads(badpickle) self.loads(badpickle)
except ValueError, detail: except ValueError, 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")
@ -716,7 +716,7 @@ class AbstractPickleTests(unittest.TestCase):
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)
@ -766,8 +766,8 @@ class AbstractPickleTests(unittest.TestCase):
# 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__ in s1) self.assertTrue(__name__ in s1)
self.assert_("MyList" in s1) self.assertTrue("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)
@ -776,8 +776,8 @@ class AbstractPickleTests(unittest.TestCase):
# 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__ not in s2) self.assertTrue(__name__ not in s2)
self.assert_("MyList" not in s2) self.assertTrue("MyList" not in s2)
self.assertEqual(opcode_in_pickle(opcode, s2), True) self.assertEqual(opcode_in_pickle(opcode, s2), True)
y = self.loads(s2) y = self.loads(s2)
@ -821,7 +821,7 @@ class AbstractPickleTests(unittest.TestCase):
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
@ -843,7 +843,7 @@ class AbstractPickleTests(unittest.TestCase):
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_StringIO.py
View file

@ -85,7 +85,7 @@ class TestGenericStringIO(unittest.TestCase):
def test_iterator(self): def test_iterator(self):
eq = self.assertEqual eq = self.assertEqual
unless = self.failUnless unless = self.assertTrue
eq(iter(self._fp), self._fp) eq(iter(self._fp), self._fp)
# Does this object support the iteration protocol? # Does this object support the iteration protocol?
unless(hasattr(self._fp, '__iter__')) unless(hasattr(self._fp, '__iter__'))

2
Lib/test/test___all__.py
View file

@ -18,7 +18,7 @@ class AllTest(unittest.TestCase):
# 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 in names exec "from %s import *" % modname in names

4
Lib/test/test___future__.py
View file

@ -15,7 +15,7 @@ class FutureTest(unittest.TestCase):
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 @@ class FutureTest(unittest.TestCase):
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

@ -44,23 +44,23 @@ class TestABC(unittest.TestCase):
def bar(self): pass # concrete def bar(self): pass # concrete
self.assertEqual(C.__abstractmethods__, set(["foo"])) self.assertEqual(C.__abstractmethods__, set(["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__, set(["foo"])) self.assertEqual(D.__abstractmethods__, set(["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__, set(["bar"])) self.assertEqual(F.__abstractmethods__, set(["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:
@ -152,41 +152,41 @@ class TestABC(unittest.TestCase):
def test_registration_transitiveness(self): def test_registration_transitiveness(self):
class A: class A:
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
self.failUnless(issubclass(A, A)) self.assertTrue(issubclass(A, A))
self.failUnless(issubclass(A, (A,))) self.assertTrue(issubclass(A, (A,)))
class B: class B:
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
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: class C:
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
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: class A:

16
Lib/test/test_abstract_numbers.py
View file

@ -9,8 +9,8 @@ from test import test_support
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,8 +19,8 @@ class TestNumbers(unittest.TestCase):
self.assertEqual(1, int(7).denominator) self.assertEqual(1, int(7).denominator)
def test_long(self): def test_long(self):
self.failUnless(issubclass(long, Integral)) self.assertTrue(issubclass(long, Integral))
self.failUnless(issubclass(long, Complex)) self.assertTrue(issubclass(long, Complex))
self.assertEqual(7, long(7).real) self.assertEqual(7, long(7).real)
self.assertEqual(0, long(7).imag) self.assertEqual(0, long(7).imag)
@ -29,16 +29,16 @@ class TestNumbers(unittest.TestCase):
self.assertEqual(1, long(7).denominator) self.assertEqual(1, long(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

@ -48,7 +48,7 @@ class BaseTest(unittest.TestCase):
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):
@ -63,10 +63,10 @@ class BaseTest(unittest.TestCase):
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, long))) self.assertTrue(isinstance(bi[0], (int, long)))
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):
@ -222,39 +222,39 @@ class BaseTest(unittest.TestCase):
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) \
@ -273,7 +273,7 @@ class BaseTest(unittest.TestCase):
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)
@ -316,22 +316,22 @@ class BaseTest(unittest.TestCase):
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

@ -122,20 +122,20 @@ eval_tests = [
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"),
@ -144,7 +144,7 @@ class AST_Tests(unittest.TestCase):
for i, o in itertools.izip(input, output): for i, o in itertools.izip(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

@ -71,7 +71,7 @@ class AugAssignTest(unittest.TestCase):
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):
@ -96,23 +96,23 @@ class AugAssignTest(unittest.TestCase):
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)

140
Lib/test/test_bigmem.py
View file

@ -130,18 +130,18 @@ class StrTest(unittest.TestCase):
except MemoryError: except MemoryError:
pass # acceptable on 32-bit pass # acceptable on 32-bit
else: else:
self.failUnless(s == eval(r)) self.assertTrue(s == eval(r))
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_endswith(self, size): def test_endswith(self, size):
SUBSTR = ' abc def ghi' SUBSTR = ' abc def ghi'
s = '-' * size + SUBSTR s = '-' * size + SUBSTR
self.failUnless(s.endswith(SUBSTR)) self.assertTrue(s.endswith(SUBSTR))
self.failUnless(s.endswith(s)) self.assertTrue(s.endswith(s))
s2 = '...' + s s2 = '...' + s
self.failUnless(s2.endswith(s)) self.assertTrue(s2.endswith(s))
self.failIf(s.endswith('a' + SUBSTR)) self.assertFalse(s.endswith('a' + SUBSTR))
self.failIf(SUBSTR.endswith(s)) self.assertFalse(SUBSTR.endswith(s))
@bigmemtest(minsize=_2G + 10, memuse=2) @bigmemtest(minsize=_2G + 10, memuse=2)
def test_expandtabs(self, size): def test_expandtabs(self, size):
@ -191,62 +191,62 @@ class StrTest(unittest.TestCase):
def test_isalnum(self, size): def test_isalnum(self, size):
SUBSTR = '123456' SUBSTR = '123456'
s = 'a' * size + SUBSTR s = 'a' * size + SUBSTR
self.failUnless(s.isalnum()) self.assertTrue(s.isalnum())
s += '.' s += '.'
self.failIf(s.isalnum()) self.assertFalse(s.isalnum())
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_isalpha(self, size): def test_isalpha(self, size):
SUBSTR = 'zzzzzzz' SUBSTR = 'zzzzzzz'
s = 'a' * size + SUBSTR s = 'a' * size + SUBSTR
self.failUnless(s.isalpha()) self.assertTrue(s.isalpha())
s += '.' s += '.'
self.failIf(s.isalpha()) self.assertFalse(s.isalpha())
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_isdigit(self, size): def test_isdigit(self, size):
SUBSTR = '123456' SUBSTR = '123456'
s = '9' * size + SUBSTR s = '9' * size + SUBSTR
self.failUnless(s.isdigit()) self.assertTrue(s.isdigit())
s += 'z' s += 'z'
self.failIf(s.isdigit()) self.assertFalse(s.isdigit())
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_islower(self, size): def test_islower(self, size):
chars = ''.join([ chr(c) for c in range(255) if not chr(c).isupper() ]) chars = ''.join([ chr(c) for c in range(255) if not chr(c).isupper() ])
repeats = size // len(chars) + 2 repeats = size // len(chars) + 2
s = chars * repeats s = chars * repeats
self.failUnless(s.islower()) self.assertTrue(s.islower())
s += 'A' s += 'A'
self.failIf(s.islower()) self.assertFalse(s.islower())
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_isspace(self, size): def test_isspace(self, size):
whitespace = ' \f\n\r\t\v' whitespace = ' \f\n\r\t\v'
repeats = size // len(whitespace) + 2 repeats = size // len(whitespace) + 2
s = whitespace * repeats s = whitespace * repeats
self.failUnless(s.isspace()) self.assertTrue(s.isspace())
s += 'j' s += 'j'
self.failIf(s.isspace()) self.assertFalse(s.isspace())
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_istitle(self, size): def test_istitle(self, size):
SUBSTR = '123456' SUBSTR = '123456'
s = ''.join(['A', 'a' * size, SUBSTR]) s = ''.join(['A', 'a' * size, SUBSTR])
self.failUnless(s.istitle()) self.assertTrue(s.istitle())
s += 'A' s += 'A'
self.failUnless(s.istitle()) self.assertTrue(s.istitle())
s += 'aA' s += 'aA'
self.failIf(s.istitle()) self.assertFalse(s.istitle())
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_isupper(self, size): def test_isupper(self, size):
chars = ''.join([ chr(c) for c in range(255) if not chr(c).islower() ]) chars = ''.join([ chr(c) for c in range(255) if not chr(c).islower() ])
repeats = size // len(chars) + 2 repeats = size // len(chars) + 2
s = chars * repeats s = chars * repeats
self.failUnless(s.isupper()) self.assertTrue(s.isupper())
s += 'a' s += 'a'
self.failIf(s.isupper()) self.assertFalse(s.isupper())
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_join(self, size): def test_join(self, size):
@ -254,14 +254,14 @@ class StrTest(unittest.TestCase):
x = s.join(['aaaaa', 'bbbbb']) x = s.join(['aaaaa', 'bbbbb'])
self.assertEquals(x.count('a'), 5) self.assertEquals(x.count('a'), 5)
self.assertEquals(x.count('b'), 5) self.assertEquals(x.count('b'), 5)
self.failUnless(x.startswith('aaaaaA')) self.assertTrue(x.startswith('aaaaaA'))
self.failUnless(x.endswith('Abbbbb')) self.assertTrue(x.endswith('Abbbbb'))
@bigmemtest(minsize=_2G + 10, memuse=1) @bigmemtest(minsize=_2G + 10, memuse=1)
def test_ljust(self, size): def test_ljust(self, size):
SUBSTR = ' abc def ghi' SUBSTR = ' abc def ghi'
s = SUBSTR.ljust(size) s = SUBSTR.ljust(size)
self.failUnless(s.startswith(SUBSTR + ' ')) self.assertTrue(s.startswith(SUBSTR + ' '))
self.assertEquals(len(s), size) self.assertEquals(len(s), size)
self.assertEquals(s.strip(), SUBSTR.strip()) self.assertEquals(s.strip(), SUBSTR.strip())
@ -282,7 +282,7 @@ class StrTest(unittest.TestCase):
s = SUBSTR.ljust(size) s = SUBSTR.ljust(size)
self.assertEquals(len(s), size) self.assertEquals(len(s), size)
stripped = s.lstrip() stripped = s.lstrip()
self.failUnless(stripped is s) self.assertTrue(stripped is s)
@bigmemtest(minsize=_2G + 10, memuse=2) @bigmemtest(minsize=_2G + 10, memuse=2)
def test_replace(self, size): def test_replace(self, size):
@ -333,7 +333,7 @@ class StrTest(unittest.TestCase):
def test_rjust(self, size): def test_rjust(self, size):
SUBSTR = ' abc def ghi' SUBSTR = ' abc def ghi'
s = SUBSTR.ljust(size) s = SUBSTR.ljust(size)
self.failUnless(s.startswith(SUBSTR + ' ')) self.assertTrue(s.startswith(SUBSTR + ' '))
self.assertEquals(len(s), size) self.assertEquals(len(s), size)
self.assertEquals(s.strip(), SUBSTR.strip()) self.assertEquals(s.strip(), SUBSTR.strip())
@ -347,7 +347,7 @@ class StrTest(unittest.TestCase):
s = SUBSTR.rjust(size) s = SUBSTR.rjust(size)
self.assertEquals(len(s), size) self.assertEquals(len(s), size)
stripped = s.rstrip() stripped = s.rstrip()
self.failUnless(stripped is s) self.assertTrue(stripped is s)
# The test takes about size bytes to build a string, and then about # The test takes about size bytes to build a string, and then about
# sqrt(size) substrings of sqrt(size) in size and a list to # sqrt(size) substrings of sqrt(size) in size and a list to
@ -399,9 +399,9 @@ class StrTest(unittest.TestCase):
def test_startswith(self, size): def test_startswith(self, size):
SUBSTR = ' abc def ghi' SUBSTR = ' abc def ghi'
s = '-' * size + SUBSTR s = '-' * size + SUBSTR
self.failUnless(s.startswith(s)) self.assertTrue(s.startswith(s))
self.failUnless(s.startswith('-' * size)) self.assertTrue(s.startswith('-' * size))
self.failIf(s.startswith(SUBSTR)) self.assertFalse(s.startswith(SUBSTR))
@bigmemtest(minsize=_2G, memuse=1) @bigmemtest(minsize=_2G, memuse=1)
def test_strip(self, size): def test_strip(self, size):
@ -430,8 +430,8 @@ class StrTest(unittest.TestCase):
SUBSTR = 'SpaaHAaaAaham' SUBSTR = 'SpaaHAaaAaham'
s = SUBSTR * (size // len(SUBSTR) + 2) s = SUBSTR * (size // len(SUBSTR) + 2)
s = s.title() s = s.title()
self.failUnless(s.startswith((SUBSTR * 3).title())) self.assertTrue(s.startswith((SUBSTR * 3).title()))
self.failUnless(s.endswith(SUBSTR.lower() * 3)) self.assertTrue(s.endswith(SUBSTR.lower() * 3))
@bigmemtest(minsize=_2G, memuse=2) @bigmemtest(minsize=_2G, memuse=2)
def test_translate(self, size): def test_translate(self, size):
@ -459,8 +459,8 @@ class StrTest(unittest.TestCase):
def test_zfill(self, size): def test_zfill(self, size):
SUBSTR = '-568324723598234' SUBSTR = '-568324723598234'
s = SUBSTR.zfill(size) s = SUBSTR.zfill(size)
self.failUnless(s.endswith('0' + SUBSTR[1:])) self.assertTrue(s.endswith('0' + SUBSTR[1:]))
self.failUnless(s.startswith('-0')) self.assertTrue(s.startswith('-0'))
self.assertEquals(len(s), size) self.assertEquals(len(s), size)
self.assertEquals(s.count('0'), size - len(SUBSTR)) self.assertEquals(s.count('0'), size - len(SUBSTR))
@ -468,12 +468,12 @@ class StrTest(unittest.TestCase):
def test_format(self, size): def test_format(self, size):
s = '-' * size s = '-' * size
sf = '%s' % (s,) sf = '%s' % (s,)
self.failUnless(s == sf) self.assertTrue(s == sf)
del sf del sf
sf = '..%s..' % (s,) sf = '..%s..' % (s,)
self.assertEquals(len(sf), len(s) + 4) self.assertEquals(len(sf), len(s) + 4)
self.failUnless(sf.startswith('..-')) self.assertTrue(sf.startswith('..-'))
self.failUnless(sf.endswith('-..')) self.assertTrue(sf.endswith('-..'))
del s, sf del s, sf
size //= 2 size //= 2
@ -519,7 +519,7 @@ class StrTest(unittest.TestCase):
@bigmemtest(minsize=2**32 / 5, memuse=6+2) @bigmemtest(minsize=2**32 / 5, memuse=6+2)
def test_unicode_repr(self, size): def test_unicode_repr(self, size):
s = u"\uAAAA" * size s = u"\uAAAA" * size
self.failUnless(len(repr(s)) > size) self.assertTrue(len(repr(s)) > size)
# This test is meaningful even with size < 2G, as long as the # This test is meaningful even with size < 2G, as long as the
# doubled string is > 2G (but it tests more if both are > 2G :) # doubled string is > 2G (but it tests more if both are > 2G :)
@ -580,24 +580,24 @@ class StrTest(unittest.TestCase):
edge = '-' * (size // 2) edge = '-' * (size // 2)
s = ''.join([edge, SUBSTR, edge]) s = ''.join([edge, SUBSTR, edge])
del edge del edge
self.failUnless(SUBSTR in s) self.assertTrue(SUBSTR in s)
self.failIf(SUBSTR * 2 in s) self.assertFalse(SUBSTR * 2 in s)
self.failUnless('-' in s) self.assertTrue('-' in s)
self.failIf('a' in s) self.assertFalse('a' in s)
s += 'a' s += 'a'
self.failUnless('a' in s) self.assertTrue('a' in s)
@bigmemtest(minsize=_2G + 10, memuse=2) @bigmemtest(minsize=_2G + 10, memuse=2)
def test_compare(self, size): def test_compare(self, size):
s1 = '-' * size s1 = '-' * size
s2 = '-' * size s2 = '-' * size
self.failUnless(s1 == s2) self.assertTrue(s1 == s2)
del s2 del s2
s2 = s1 + 'a' s2 = s1 + 'a'
self.failIf(s1 == s2) self.assertFalse(s1 == s2)
del s2 del s2
s2 = '.' * size s2 = '.' * size
self.failIf(s1 == s2) self.assertFalse(s1 == s2)
@bigmemtest(minsize=_2G + 10, memuse=1) @bigmemtest(minsize=_2G + 10, memuse=1)
def test_hash(self, size): def test_hash(self, size):
@ -611,7 +611,7 @@ class StrTest(unittest.TestCase):
h1 = hash(s) h1 = hash(s)
del s del s
s = '\x00' * (size + 1) s = '\x00' * (size + 1)
self.failIf(h1 == hash(s)) self.assertFalse(h1 == hash(s))
class TupleTest(unittest.TestCase): class TupleTest(unittest.TestCase):
@ -628,13 +628,13 @@ class TupleTest(unittest.TestCase):
def test_compare(self, size): def test_compare(self, size):
t1 = (u'',) * size t1 = (u'',) * size
t2 = (u'',) * size t2 = (u'',) * size
self.failUnless(t1 == t2) self.assertTrue(t1 == t2)
del t2 del t2
t2 = (u'',) * (size + 1) t2 = (u'',) * (size + 1)
self.failIf(t1 == t2) self.assertFalse(t1 == t2)
del t2 del t2
t2 = (1,) * size t2 = (1,) * size
self.failIf(t1 == t2) self.assertFalse(t1 == t2)
# Test concatenating into a single tuple of more than 2G in length, # Test concatenating into a single tuple of more than 2G in length,
# and concatenating a tuple of more than 2G in length separately, so # and concatenating a tuple of more than 2G in length separately, so
@ -659,9 +659,9 @@ class TupleTest(unittest.TestCase):
def test_contains(self, size): def test_contains(self, size):
t = (1, 2, 3, 4, 5) * size t = (1, 2, 3, 4, 5) * size
self.assertEquals(len(t), size * 5) self.assertEquals(len(t), size * 5)
self.failUnless(5 in t) self.assertTrue(5 in t)
self.failIf((1, 2, 3, 4, 5) in t) self.assertFalse((1, 2, 3, 4, 5) in t)
self.failIf(0 in t) self.assertFalse(0 in t)
@bigmemtest(minsize=_2G + 10, memuse=8) @bigmemtest(minsize=_2G + 10, memuse=8)
def test_hash(self, size): def test_hash(self, size):
@ -669,7 +669,7 @@ class TupleTest(unittest.TestCase):
h1 = hash(t1) h1 = hash(t1)
del t1 del t1
t2 = (0,) * (size + 1) t2 = (0,) * (size + 1)
self.failIf(h1 == hash(t2)) self.assertFalse(h1 == hash(t2))
@bigmemtest(minsize=_2G + 10, memuse=8) @bigmemtest(minsize=_2G + 10, memuse=8)
def test_index_and_slice(self, size): def test_index_and_slice(self, size):
@ -762,13 +762,13 @@ class ListTest(unittest.TestCase):
def test_compare(self, size): def test_compare(self, size):
l1 = [u''] * size l1 = [u''] * size
l2 = [u''] * size l2 = [u''] * size
self.failUnless(l1 == l2) self.assertTrue(l1 == l2)
del l2 del l2
l2 = [u''] * (size + 1) l2 = [u''] * (size + 1)
self.failIf(l1 == l2) self.assertFalse(l1 == l2)
del l2 del l2
l2 = [2] * size l2 = [2] * size
self.failIf(l1 == l2) self.assertFalse(l1 == l2)
# Test concatenating into a single list of more than 2G in length, # Test concatenating into a single list of more than 2G in length,
# and concatenating a list of more than 2G in length separately, so # and concatenating a list of more than 2G in length separately, so
@ -793,8 +793,8 @@ class ListTest(unittest.TestCase):
l = [sys.stdout] * size l = [sys.stdout] * size
l += l l += l
self.assertEquals(len(l), size * 2) self.assertEquals(len(l), size * 2)
self.failUnless(l[0] is l[-1]) self.assertTrue(l[0] is l[-1])
self.failUnless(l[size - 1] is l[size + 1]) self.assertTrue(l[size - 1] is l[size + 1])
@bigmemtest(minsize=_2G // 2 + 2, memuse=24) @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
def test_inplace_concat_small(self, size): def test_inplace_concat_small(self, size):
@ -808,14 +808,14 @@ class ListTest(unittest.TestCase):
def test_contains(self, size): def test_contains(self, size):
l = [1, 2, 3, 4, 5] * size l = [1, 2, 3, 4, 5] * size
self.assertEquals(len(l), size * 5) self.assertEquals(len(l), size * 5)
self.failUnless(5 in l) self.assertTrue(5 in l)
self.failIf([1, 2, 3, 4, 5] in l) self.assertFalse([1, 2, 3, 4, 5] in l)
self.failIf(0 in l) self.assertFalse(0 in l)
@bigmemtest(minsize=_2G + 10, memuse=8) @bigmemtest(minsize=_2G + 10, memuse=8)
def test_hash(self, size): def test_hash(self, size):
l = [0] * size l = [0] * size
self.failUnlessRaises(TypeError, hash, l) self.assertRaises(TypeError, hash, l)
@bigmemtest(minsize=_2G + 10, memuse=8) @bigmemtest(minsize=_2G + 10, memuse=8)
def test_index_and_slice(self, size): def test_index_and_slice(self, size):
@ -875,7 +875,7 @@ class ListTest(unittest.TestCase):
# Like test_concat, split in two. # Like test_concat, split in two.
def basic_test_repeat(self, size): def basic_test_repeat(self, size):
l = [] * size l = [] * size
self.failIf(l) self.assertFalse(l)
l = [''] * size l = [''] * size
self.assertEquals(len(l), size) self.assertEquals(len(l), size)
l = l * 2 l = l * 2
@ -893,13 +893,13 @@ class ListTest(unittest.TestCase):
l = [''] l = ['']
l *= size l *= size
self.assertEquals(len(l), size) self.assertEquals(len(l), size)
self.failUnless(l[0] is l[-1]) self.assertTrue(l[0] is l[-1])
del l del l
l = [''] * size l = [''] * size
l *= 2 l *= 2
self.assertEquals(len(l), size * 2) self.assertEquals(len(l), size * 2)
self.failUnless(l[size - 1] is l[-1]) self.assertTrue(l[size - 1] is l[-1])
@bigmemtest(minsize=_2G // 2 + 2, memuse=16) @bigmemtest(minsize=_2G // 2 + 2, memuse=16)
def test_inplace_repeat_small(self, size): def test_inplace_repeat_small(self, size):
@ -933,8 +933,8 @@ class ListTest(unittest.TestCase):
l = [object()] * size l = [object()] * size
l.append(object()) l.append(object())
self.assertEquals(len(l), size+1) self.assertEquals(len(l), size+1)
self.failUnless(l[-3] is l[-2]) self.assertTrue(l[-3] is l[-2])
self.failIf(l[-2] is l[-1]) self.assertFalse(l[-2] is l[-1])
@bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
def test_count(self, size): def test_count(self, size):
@ -946,8 +946,8 @@ class ListTest(unittest.TestCase):
l = [file] * size l = [file] * size
l.extend(l) l.extend(l)
self.assertEquals(len(l), size * 2) self.assertEquals(len(l), size * 2)
self.failUnless(l[0] is l[-1]) self.assertTrue(l[0] is l[-1])
self.failUnless(l[size - 1] is l[size + 1]) self.assertTrue(l[size - 1] is l[size + 1])
@bigmemtest(minsize=_2G // 2 + 2, memuse=16) @bigmemtest(minsize=_2G // 2 + 2, memuse=16)
def test_extend_small(self, size): def test_extend_small(self, size):

8
Lib/test/test_binascii.py
View file

@ -14,8 +14,8 @@ class BinASCIITest(unittest.TestCase):
def test_exceptions(self): def test_exceptions(self):
# Check module exceptions # Check module exceptions
self.assert_(issubclass(binascii.Error, Exception)) self.assertTrue(issubclass(binascii.Error, Exception))
self.assert_(issubclass(binascii.Incomplete, Exception)) self.assertTrue(issubclass(binascii.Incomplete, Exception))
def test_functions(self): def test_functions(self):
# Check presence of all functions # Check presence of all functions
@ -26,10 +26,10 @@ class BinASCIITest(unittest.TestCase):
prefixes.extend(["crc_", "rlecode_", "rledecode_"]) prefixes.extend(["crc_", "rlecode_", "rledecode_"])
for prefix in prefixes: for prefix in prefixes:
name = prefix + suffix name = prefix + suffix
self.assert_(callable(getattr(binascii, name))) self.assertTrue(callable(getattr(binascii, name)))
self.assertRaises(TypeError, getattr(binascii, name)) self.assertRaises(TypeError, getattr(binascii, name))
for name in ("hexlify", "unhexlify"): for name in ("hexlify", "unhexlify"):
self.assert_(callable(getattr(binascii, name))) self.assertTrue(callable(getattr(binascii, name)))
self.assertRaises(TypeError, getattr(binascii, name)) self.assertRaises(TypeError, getattr(binascii, name))
def test_base64valid(self): def test_base64valid(self):

8
Lib/test/test_binop.py
View file

@ -220,10 +220,10 @@ class RatTestCase(unittest.TestCase):
self.assertEqual(gcd(-10, -2), -2) self.assertEqual(gcd(-10, -2), -2)
for i in range(1, 20): for i in range(1, 20):
for j in range(1, 20): for j in range(1, 20):
self.assert_(gcd(i, j) > 0) self.assertTrue(gcd(i, j) > 0)
self.assert_(gcd(-i, j) < 0) self.assertTrue(gcd(-i, j) < 0)
self.assert_(gcd(i, -j) > 0) self.assertTrue(gcd(i, -j) > 0)
self.assert_(gcd(-i, -j) < 0) self.assertTrue(gcd(-i, -j) < 0)
def test_constructor(self): def test_constructor(self):
a = Rat(10, 15) a = Rat(10, 15)

18
Lib/test/test_bisect.py
View file

@ -130,14 +130,14 @@ class TestBisect(unittest.TestCase):
elem = randrange(-1, n+1) elem = randrange(-1, n+1)
ip = self.module.bisect_left(data, elem) ip = self.module.bisect_left(data, elem)
if ip < len(data): if ip < len(data):
self.failUnless(elem <= data[ip]) self.assertTrue(elem <= data[ip])
if ip > 0: if ip > 0:
self.failUnless(data[ip-1] < elem) self.assertTrue(data[ip-1] < elem)
ip = self.module.bisect_right(data, elem) ip = self.module.bisect_right(data, elem)
if ip < len(data): if ip < len(data):
self.failUnless(elem < data[ip]) self.assertTrue(elem < data[ip])
if ip > 0: if ip > 0:
self.failUnless(data[ip-1] <= elem) self.assertTrue(data[ip-1] <= elem)
def test_optionalSlicing(self): def test_optionalSlicing(self):
for func, data, elem, expected in self.precomputedCases: for func, data, elem, expected in self.precomputedCases:
@ -146,15 +146,15 @@ class TestBisect(unittest.TestCase):
for hi in xrange(3,8): for hi in xrange(3,8):
hi = min(len(data), hi) hi = min(len(data), hi)
ip = func(data, elem, lo, hi) ip = func(data, elem, lo, hi)
self.failUnless(lo <= ip <= hi) self.assertTrue(lo <= ip <= hi)
if func is self.module.bisect_left and ip < hi: if func is self.module.bisect_left and ip < hi:
self.failUnless(elem <= data[ip]) self.assertTrue(elem <= data[ip])
if func is self.module.bisect_left and ip > lo: if func is self.module.bisect_left and ip > lo:
self.failUnless(data[ip-1] < elem) self.assertTrue(data[ip-1] < elem)
if func is self.module.bisect_right and ip < hi: if func is self.module.bisect_right and ip < hi:
self.failUnless(elem < data[ip]) self.assertTrue(elem < data[ip])
if func is self.module.bisect_right and ip > lo: if func is self.module.bisect_right and ip > lo:
self.failUnless(data[ip-1] <= elem) self.assertTrue(data[ip-1] <= elem)
self.assertEqual(ip, max(lo, min(hi, expected))) self.assertEqual(ip, max(lo, min(hi, expected)))
def test_backcompatibility(self): def test_backcompatibility(self):

10
Lib/test/test_bool.py
View file

@ -8,10 +8,10 @@ import os
class BoolTest(unittest.TestCase): class BoolTest(unittest.TestCase):
def assertIs(self, a, b): def assertIs(self, a, b):
self.assert_(a is b) self.assertTrue(a is b)
def assertIsNot(self, a, b): def assertIsNot(self, a, b):
self.assert_(a is not b) self.assertTrue(a is not b)
def test_subclass(self): def test_subclass(self):
try: try:
@ -233,15 +233,15 @@ class BoolTest(unittest.TestCase):
def test_boolean(self): def test_boolean(self):
self.assertEqual(True & 1, 1) self.assertEqual(True & 1, 1)
self.assert_(not isinstance(True & 1, bool)) self.assertTrue(not isinstance(True & 1, bool))
self.assertIs(True & True, True) self.assertIs(True & True, True)
self.assertEqual(True | 1, 1) self.assertEqual(True | 1, 1)
self.assert_(not isinstance(True | 1, bool)) self.assertTrue(not isinstance(True | 1, bool))
self.assertIs(True | True, True) self.assertIs(True | True, True)
self.assertEqual(True ^ 1, 0) self.assertEqual(True ^ 1, 0)
self.assert_(not isinstance(True ^ 1, bool)) self.assertTrue(not isinstance(True ^ 1, bool))
self.assertIs(True ^ True, False) self.assertIs(True ^ True, False)
def test_fileclosed(self): def test_fileclosed(self):

34
Lib/test/test_bsddb.py
View file

@ -43,8 +43,8 @@ class TestBSDDB(unittest.TestCase):
def test_change(self): def test_change(self):
self.f['r'] = 'discovered' self.f['r'] = 'discovered'
self.assertEqual(self.f['r'], 'discovered') self.assertEqual(self.f['r'], 'discovered')
self.assert_('r' in self.f.keys()) self.assertTrue('r' in self.f.keys())
self.assert_('discovered' in self.f.values()) self.assertTrue('discovered' in self.f.values())
def test_close_and_reopen(self): def test_close_and_reopen(self):
if self.fname is None: if self.fname is None:
@ -176,7 +176,7 @@ class TestBSDDB(unittest.TestCase):
def test_first_while_deleting(self): def test_first_while_deleting(self):
# Test for bug 1725856 # Test for bug 1725856
self.assert_(len(self.d) >= 2, "test requires >=2 items") self.assertTrue(len(self.d) >= 2, "test requires >=2 items")
for _ in self.d: for _ in self.d:
key = self.f.first()[0] key = self.f.first()[0]
del self.f[key] del self.f[key]
@ -184,7 +184,7 @@ class TestBSDDB(unittest.TestCase):
def test_last_while_deleting(self): def test_last_while_deleting(self):
# Test for bug 1725856's evil twin # Test for bug 1725856's evil twin
self.assert_(len(self.d) >= 2, "test requires >=2 items") self.assertTrue(len(self.d) >= 2, "test requires >=2 items")
for _ in self.d: for _ in self.d:
key = self.f.last()[0] key = self.f.last()[0]
del self.f[key] del self.f[key]
@ -195,13 +195,13 @@ class TestBSDDB(unittest.TestCase):
def test_contains(self): def test_contains(self):
for k in self.d: for k in self.d:
self.assert_(k in self.f) self.assertTrue(k in self.f)
self.assert_('not here' not in self.f) self.assertTrue('not here' not in self.f)
def test_has_key(self): def test_has_key(self):
for k in self.d: for k in self.d:
self.assert_(self.f.has_key(k)) self.assertTrue(self.f.has_key(k))
self.assert_(not self.f.has_key('not here')) self.assertTrue(not self.f.has_key('not here'))
def test_clear(self): def test_clear(self):
self.f.clear() self.f.clear()
@ -253,11 +253,11 @@ class TestBSDDB(unittest.TestCase):
if debug: print "K" if debug: print "K"
# test the legacy cursor interface mixed with writes # test the legacy cursor interface mixed with writes
self.assert_(self.f.first()[0] in self.d) self.assertTrue(self.f.first()[0] in self.d)
k = self.f.next()[0] k = self.f.next()[0]
self.assert_(k in self.d) self.assertTrue(k in self.d)
self.f[k] = "be gone with ye deadlocks" self.f[k] = "be gone with ye deadlocks"
self.assert_(self.f[k], "be gone with ye deadlocks") self.assertTrue(self.f[k], "be gone with ye deadlocks")
def test_for_cursor_memleak(self): def test_for_cursor_memleak(self):
# do the bsddb._DBWithCursor iterator internals leak cursors? # do the bsddb._DBWithCursor iterator internals leak cursors?
@ -275,21 +275,21 @@ class TestBSDDB(unittest.TestCase):
self.assertEqual(nc1, nc2) self.assertEqual(nc1, nc2)
self.assertEqual(nc1, nc4) self.assertEqual(nc1, nc4)
self.assert_(nc3 == nc1+1) self.assertTrue(nc3 == nc1+1)
def test_popitem(self): def test_popitem(self):
k, v = self.f.popitem() k, v = self.f.popitem()
self.assert_(k in self.d) self.assertTrue(k in self.d)
self.assert_(v in self.d.values()) self.assertTrue(v in self.d.values())
self.assert_(k not in self.f) self.assertTrue(k not in self.f)
self.assertEqual(len(self.d)-1, len(self.f)) self.assertEqual(len(self.d)-1, len(self.f))
def test_pop(self): def test_pop(self):
k = 'w' k = 'w'
v = self.f.pop(k) v = self.f.pop(k)
self.assertEqual(v, self.d[k]) self.assertEqual(v, self.d[k])
self.assert_(k not in self.f) self.assertTrue(k not in self.f)
self.assert_(v not in self.f.values()) self.assertTrue(v not in self.f.values())
self.assertEqual(len(self.d)-1, len(self.f)) self.assertEqual(len(self.d)-1, len(self.f))
def test_get(self): def test_get(self):

2
Lib/test/test_bufio.py
View file

@ -34,7 +34,7 @@ class BufferSizeTest(unittest.TestCase):
line = f.readline() line = f.readline()
self.assertEqual(line, s) self.assertEqual(line, s)
line = f.readline() line = f.readline()
self.assert_(not line) # Must be at EOF self.assertTrue(not line) # Must be at EOF
f.close() f.close()
finally: finally:
support.unlink(support.TESTFN) support.unlink(support.TESTFN)

84
Lib/test/test_builtin.py
View file

@ -122,7 +122,7 @@ class BuiltinTest(unittest.TestCase):
def test_neg(self): def test_neg(self):
x = -sys.maxint-1 x = -sys.maxint-1
self.assert_(isinstance(x, int)) self.assertTrue(isinstance(x, int))
self.assertEqual(-x, sys.maxint+1) self.assertEqual(-x, sys.maxint+1)
def test_apply(self): def test_apply(self):
@ -152,19 +152,19 @@ class BuiltinTest(unittest.TestCase):
self.assertRaises(TypeError, apply, id, (42,), 42) self.assertRaises(TypeError, apply, id, (42,), 42)
def test_callable(self): def test_callable(self):
self.assert_(callable(len)) self.assertTrue(callable(len))
def f(): pass def f(): pass
self.assert_(callable(f)) self.assertTrue(callable(f))
class C: class C:
def meth(self): pass def meth(self): pass
self.assert_(callable(C)) self.assertTrue(callable(C))
x = C() x = C()
self.assert_(callable(x.meth)) self.assertTrue(callable(x.meth))
self.assert_(not callable(x)) self.assertTrue(not callable(x))
class D(C): class D(C):
def __call__(self): pass def __call__(self): pass
y = D() y = D()
self.assert_(callable(y)) self.assertTrue(callable(y))
y() y()
def test_chr(self): def test_chr(self):
@ -193,9 +193,9 @@ class BuiltinTest(unittest.TestCase):
self.assertRaises(TypeError, cmp) self.assertRaises(TypeError, cmp)
def test_coerce(self): def test_coerce(self):
self.assert_(not fcmp(coerce(1, 1.1), (1.0, 1.1))) self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1)))
self.assertEqual(coerce(1, 1L), (1L, 1L)) self.assertEqual(coerce(1, 1L), (1L, 1L))
self.assert_(not fcmp(coerce(1L, 1.1), (1.0, 1.1))) self.assertTrue(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))
self.assertRaises(TypeError, coerce) self.assertRaises(TypeError, coerce)
class BadNumber: class BadNumber:
def __coerce__(self, other): def __coerce__(self, other):
@ -234,11 +234,11 @@ class BuiltinTest(unittest.TestCase):
# dir() - local scope # dir() - local scope
local_var = 1 local_var = 1
self.assert_('local_var' in dir()) self.assertTrue('local_var' in dir())
# dir(module) # dir(module)
import sys import sys
self.assert_('exit' in dir(sys)) self.assertTrue('exit' in dir(sys))
# dir(module_with_invalid__dict__) # dir(module_with_invalid__dict__)
import types import types
@ -248,8 +248,8 @@ class BuiltinTest(unittest.TestCase):
self.assertRaises(TypeError, dir, f) self.assertRaises(TypeError, dir, f)
# dir(type) # dir(type)
self.assert_("strip" in dir(str)) self.assertTrue("strip" in dir(str))
self.assert_("__mro__" not in dir(str)) self.assertTrue("__mro__" not in dir(str))
# dir(obj) # dir(obj)
class Foo(object): class Foo(object):
@ -258,13 +258,13 @@ class BuiltinTest(unittest.TestCase):
self.y = 8 self.y = 8
self.z = 9 self.z = 9
f = Foo() f = Foo()
self.assert_("y" in dir(f)) self.assertTrue("y" in dir(f))
# dir(obj_no__dict__) # dir(obj_no__dict__)
class Foo(object): class Foo(object):
__slots__ = [] __slots__ = []
f = Foo() f = Foo()
self.assert_("__repr__" in dir(f)) self.assertTrue("__repr__" in dir(f))
# dir(obj_no__class__with__dict__) # dir(obj_no__class__with__dict__)
# (an ugly trick to cause getattr(f, "__class__") to fail) # (an ugly trick to cause getattr(f, "__class__") to fail)
@ -273,15 +273,15 @@ class BuiltinTest(unittest.TestCase):
def __init__(self): def __init__(self):
self.bar = "wow" self.bar = "wow"
f = Foo() f = Foo()
self.assert_("__repr__" not in dir(f)) self.assertTrue("__repr__" not in dir(f))
self.assert_("bar" in dir(f)) self.assertTrue("bar" in dir(f))
# dir(obj_using __dir__) # dir(obj_using __dir__)
class Foo(object): class Foo(object):
def __dir__(self): def __dir__(self):
return ["kan", "ga", "roo"] return ["kan", "ga", "roo"]
f = Foo() f = Foo()
self.assert_(dir(f) == ["ga", "kan", "roo"]) self.assertTrue(dir(f) == ["ga", "kan", "roo"])
# dir(obj__dir__not_list) # dir(obj__dir__not_list)
class Foo(object): class Foo(object):
@ -309,10 +309,10 @@ class BuiltinTest(unittest.TestCase):
self.assertEqual(divmod(-sys.maxint-1, -1), self.assertEqual(divmod(-sys.maxint-1, -1),
(sys.maxint+1, 0)) (sys.maxint+1, 0))
self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
self.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
self.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
self.assertRaises(TypeError, divmod) self.assertRaises(TypeError, divmod)
@ -571,11 +571,11 @@ class BuiltinTest(unittest.TestCase):
for func in funcs: for func in funcs:
outp = filter(func, cls(inp)) outp = filter(func, cls(inp))
self.assertEqual(outp, exp) self.assertEqual(outp, exp)
self.assert_(not isinstance(outp, cls)) self.assertTrue(not isinstance(outp, cls))
def test_getattr(self): def test_getattr(self):
import sys import sys
self.assert_(getattr(sys, 'stdout') is sys.stdout) self.assertTrue(getattr(sys, 'stdout') is sys.stdout)
self.assertRaises(TypeError, getattr, sys, 1) self.assertRaises(TypeError, getattr, sys, 1)
self.assertRaises(TypeError, getattr, sys, 1, "foo") self.assertRaises(TypeError, getattr, sys, 1, "foo")
self.assertRaises(TypeError, getattr) self.assertRaises(TypeError, getattr)
@ -584,7 +584,7 @@ class BuiltinTest(unittest.TestCase):
def test_hasattr(self): def test_hasattr(self):
import sys import sys
self.assert_(hasattr(sys, 'stdout')) self.assertTrue(hasattr(sys, 'stdout'))
self.assertRaises(TypeError, hasattr, sys, 1) self.assertRaises(TypeError, hasattr, sys, 1)
self.assertRaises(TypeError, hasattr) self.assertRaises(TypeError, hasattr)
if have_unicode: if have_unicode:
@ -647,9 +647,9 @@ class BuiltinTest(unittest.TestCase):
def test_intern(self): def test_intern(self):
self.assertRaises(TypeError, intern) self.assertRaises(TypeError, intern)
s = "never interned before" s = "never interned before"
self.assert_(intern(s) is s) self.assertTrue(intern(s) is s)
s2 = s.swapcase().swapcase() s2 = s.swapcase().swapcase()
self.assert_(intern(s2) is s) self.assertTrue(intern(s2) is s)
# Subclasses of string can't be interned, because they # Subclasses of string can't be interned, because they
# provide too much opportunity for insane things to happen. # provide too much opportunity for insane things to happen.
@ -690,11 +690,11 @@ class BuiltinTest(unittest.TestCase):
c = C() c = C()
d = D() d = D()
e = E() e = E()
self.assert_(isinstance(c, C)) self.assertTrue(isinstance(c, C))
self.assert_(isinstance(d, C)) self.assertTrue(isinstance(d, C))
self.assert_(not isinstance(e, C)) self.assertTrue(not isinstance(e, C))
self.assert_(not isinstance(c, D)) self.assertTrue(not isinstance(c, D))
self.assert_(not isinstance('foo', E)) self.assertTrue(not isinstance('foo', E))
self.assertRaises(TypeError, isinstance, E, 'foo') self.assertRaises(TypeError, isinstance, E, 'foo')
self.assertRaises(TypeError, isinstance) self.assertRaises(TypeError, isinstance)
@ -708,9 +708,9 @@ class BuiltinTest(unittest.TestCase):
c = C() c = C()
d = D() d = D()
e = E() e = E()
self.assert_(issubclass(D, C)) self.assertTrue(issubclass(D, C))
self.assert_(issubclass(C, C)) self.assertTrue(issubclass(C, C))
self.assert_(not issubclass(C, D)) self.assertTrue(not issubclass(C, D))
self.assertRaises(TypeError, issubclass, 'foo', E) self.assertRaises(TypeError, issubclass, 'foo', E)
self.assertRaises(TypeError, issubclass, E, 'foo') self.assertRaises(TypeError, issubclass, E, 'foo')
self.assertRaises(TypeError, issubclass) self.assertRaises(TypeError, issubclass)
@ -1042,18 +1042,18 @@ class BuiltinTest(unittest.TestCase):
self.assertEqual(range(a+4, a, -2), [a+4, a+2]) self.assertEqual(range(a+4, a, -2), [a+4, a+2])
seq = range(a, b, c) seq = range(a, b, c)
self.assert_(a in seq) self.assertTrue(a in seq)
self.assert_(b not in seq) self.assertTrue(b not in seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
seq = range(b, a, -c) seq = range(b, a, -c)
self.assert_(b in seq) self.assertTrue(b in seq)
self.assert_(a not in seq) self.assertTrue(a not in seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
seq = range(-a, -b, -c) seq = range(-a, -b, -c)
self.assert_(-a in seq) self.assertTrue(-a in seq)
self.assert_(-b not in seq) self.assertTrue(-b not in seq)
self.assertEqual(len(seq), 2) self.assertEqual(len(seq), 2)
self.assertRaises(TypeError, range) self.assertRaises(TypeError, range)
@ -1452,7 +1452,7 @@ class BuiltinTest(unittest.TestCase):
# tests for object.__format__ really belong elsewhere, but # tests for object.__format__ really belong elsewhere, but
# there's no good place to put them # there's no good place to put them
x = object().__format__('') x = object().__format__('')
self.assert_(x.startswith('<object object at')) self.assertTrue(x.startswith('<object object at'))
# first argument to object.__format__ must be string # first argument to object.__format__ must be string
self.assertRaises(TypeError, object().__format__, 3) self.assertRaises(TypeError, object().__format__, 3)

108
Lib/test/test_bytes.py
View file

@ -102,22 +102,22 @@ class BaseBytesTest(unittest.TestCase):
b3 = self.type2test([1, 3]) b3 = self.type2test([1, 3])
self.assertEqual(b1, b2) self.assertEqual(b1, b2)
self.failUnless(b2 != b3) self.assertTrue(b2 != b3)
self.failUnless(b1 <= b2) self.assertTrue(b1 <= b2)
self.failUnless(b1 <= b3) self.assertTrue(b1 <= b3)
self.failUnless(b1 < b3) self.assertTrue(b1 < b3)
self.failUnless(b1 >= b2) self.assertTrue(b1 >= b2)
self.failUnless(b3 >= b2) self.assertTrue(b3 >= b2)
self.failUnless(b3 > b2) self.assertTrue(b3 > b2)
self.failIf(b1 != b2) self.assertFalse(b1 != b2)
self.failIf(b2 == b3) self.assertFalse(b2 == b3)
self.failIf(b1 > b2) self.assertFalse(b1 > b2)
self.failIf(b1 > b3) self.assertFalse(b1 > b3)
self.failIf(b1 >= b3) self.assertFalse(b1 >= b3)
self.failIf(b1 < b2) self.assertFalse(b1 < b2)
self.failIf(b3 < b2) self.assertFalse(b3 < b2)
self.failIf(b3 <= b2) self.assertFalse(b3 <= b2)
def test_compare_to_str(self): def test_compare_to_str(self):
warnings.simplefilter('ignore', BytesWarning) warnings.simplefilter('ignore', BytesWarning)
@ -220,27 +220,27 @@ class BaseBytesTest(unittest.TestCase):
def test_contains(self): def test_contains(self):
b = self.type2test(b"abc") b = self.type2test(b"abc")
self.failUnless(ord('a') in b) self.assertTrue(ord('a') in b)
self.failUnless(int(ord('a')) in b) self.assertTrue(int(ord('a')) in b)
self.failIf(200 in b) self.assertFalse(200 in b)
self.failIf(200 in b) self.assertFalse(200 in b)
self.assertRaises(ValueError, lambda: 300 in b) self.assertRaises(ValueError, lambda: 300 in b)
self.assertRaises(ValueError, lambda: -1 in b) self.assertRaises(ValueError, lambda: -1 in b)
self.assertRaises(TypeError, lambda: None in b) self.assertRaises(TypeError, lambda: None in b)
self.assertRaises(TypeError, lambda: float(ord('a')) in b) self.assertRaises(TypeError, lambda: float(ord('a')) in b)
self.assertRaises(TypeError, lambda: u"a" in b) self.assertRaises(TypeError, lambda: u"a" in b)
for f in bytes, bytearray: for f in bytes, bytearray:
self.failUnless(f(b"") in b) self.assertTrue(f(b"") in b)
self.failUnless(f(b"a") in b) self.assertTrue(f(b"a") in b)
self.failUnless(f(b"b") in b) self.assertTrue(f(b"b") in b)
self.failUnless(f(b"c") in b) self.assertTrue(f(b"c") in b)
self.failUnless(f(b"ab") in b) self.assertTrue(f(b"ab") in b)
self.failUnless(f(b"bc") in b) self.assertTrue(f(b"bc") in b)
self.failUnless(f(b"abc") in b) self.assertTrue(f(b"abc") in b)
self.failIf(f(b"ac") in b) self.assertFalse(f(b"ac") in b)
self.failIf(f(b"d") in b) self.assertFalse(f(b"d") in b)
self.failIf(f(b"dab") in b) self.assertFalse(f(b"dab") in b)
self.failIf(f(b"abd") in b) self.assertFalse(f(b"abd") in b)
def test_fromhex(self): def test_fromhex(self):
self.assertRaises(TypeError, self.type2test.fromhex) self.assertRaises(TypeError, self.type2test.fromhex)
@ -600,7 +600,7 @@ class ByteArrayTest(BaseBytesTest):
b += b"def" b += b"def"
self.assertEqual(b, b"abcdef") self.assertEqual(b, b"abcdef")
self.assertEqual(b, b1) self.assertEqual(b, b1)
self.failUnless(b is b1) self.assertTrue(b is b1)
b += b"xyz" b += b"xyz"
self.assertEqual(b, b"abcdefxyz") self.assertEqual(b, b"abcdefxyz")
try: try:
@ -616,7 +616,7 @@ class ByteArrayTest(BaseBytesTest):
b *= 3 b *= 3
self.assertEqual(b, b"abcabcabc") self.assertEqual(b, b"abcabcabc")
self.assertEqual(b, b1) self.assertEqual(b, b1)
self.failUnless(b is b1) self.assertTrue(b is b1)
def test_irepeat_1char(self): def test_irepeat_1char(self):
b = bytearray(b"x") b = bytearray(b"x")
@ -624,17 +624,17 @@ class ByteArrayTest(BaseBytesTest):
b *= 100 b *= 100
self.assertEqual(b, b"x"*100) self.assertEqual(b, b"x"*100)
self.assertEqual(b, b1) self.assertEqual(b, b1)
self.failUnless(b is b1) self.assertTrue(b is b1)
def test_alloc(self): def test_alloc(self):
b = bytearray() b = bytearray()
alloc = b.__alloc__() alloc = b.__alloc__()
self.assert_(alloc >= 0) self.assertTrue(alloc >= 0)
seq = [alloc] seq = [alloc]
for i in range(100): for i in range(100):
b += b"x" b += b"x"
alloc = b.__alloc__() alloc = b.__alloc__()
self.assert_(alloc >= len(b)) self.assertTrue(alloc >= len(b))
if alloc not in seq: if alloc not in seq:
seq.append(alloc) seq.append(alloc)
@ -734,7 +734,7 @@ class ByteArrayTest(BaseBytesTest):
a, b, c = bytearray(b"x").partition(b"y") a, b, c = bytearray(b"x").partition(b"y")
self.assertEqual(b, b"") self.assertEqual(b, b"")
self.assertEqual(c, b"") self.assertEqual(c, b"")
self.assert_(b is not c) self.assertTrue(b is not c)
b += b"!" b += b"!"
self.assertEqual(c, b"") self.assertEqual(c, b"")
a, b, c = bytearray(b"x").partition(b"y") a, b, c = bytearray(b"x").partition(b"y")
@ -744,7 +744,7 @@ class ByteArrayTest(BaseBytesTest):
b, c, a = bytearray(b"x").rpartition(b"y") b, c, a = bytearray(b"x").rpartition(b"y")
self.assertEqual(b, b"") self.assertEqual(b, b"")
self.assertEqual(c, b"") self.assertEqual(c, b"")
self.assert_(b is not c) self.assertTrue(b is not c)
b += b"!" b += b"!"
self.assertEqual(c, b"") self.assertEqual(c, b"")
c, b, a = bytearray(b"x").rpartition(b"y") c, b, a = bytearray(b"x").rpartition(b"y")
@ -836,10 +836,10 @@ class AssortedBytesTest(unittest.TestCase):
self.assertEqual(bytes(b"abc") <= b"ab", False) self.assertEqual(bytes(b"abc") <= b"ab", False)
def test_doc(self): def test_doc(self):
self.failUnless(bytearray.__doc__ != None) self.assertTrue(bytearray.__doc__ != None)
self.failUnless(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__) self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
self.failUnless(bytes.__doc__ != None) self.assertTrue(bytes.__doc__ != None)
self.failUnless(bytes.__doc__.startswith("bytes("), bytes.__doc__) self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__)
def test_from_bytearray(self): def test_from_bytearray(self):
sample = bytes(b"Hello world\n\x80\x81\xfe\xff") sample = bytes(b"Hello world\n\x80\x81\xfe\xff")
@ -958,20 +958,20 @@ class ByteArraySubclass(bytearray):
class ByteArraySubclassTest(unittest.TestCase): class ByteArraySubclassTest(unittest.TestCase):
def test_basic(self): def test_basic(self):
self.assert_(issubclass(ByteArraySubclass, bytearray)) self.assertTrue(issubclass(ByteArraySubclass, bytearray))
self.assert_(isinstance(ByteArraySubclass(), bytearray)) self.assertTrue(isinstance(ByteArraySubclass(), bytearray))
a, b = b"abcd", b"efgh" a, b = b"abcd", b"efgh"
_a, _b = ByteArraySubclass(a), ByteArraySubclass(b) _a, _b = ByteArraySubclass(a), ByteArraySubclass(b)
# test comparison operators with subclass instances # test comparison operators with subclass instances
self.assert_(_a == _a) self.assertTrue(_a == _a)
self.assert_(_a != _b) self.assertTrue(_a != _b)
self.assert_(_a < _b) self.assertTrue(_a < _b)
self.assert_(_a <= _b) self.assertTrue(_a <= _b)
self.assert_(_b >= _a) self.assertTrue(_b >= _a)
self.assert_(_b > _a) self.assertTrue(_b > _a)
self.assert_(_a is not a) self.assertTrue(_a is not a)
# test concat of subclass instances # test concat of subclass instances
self.assertEqual(a + b, _a + _b) self.assertEqual(a + b, _a + _b)
@ -979,7 +979,7 @@ class ByteArraySubclassTest(unittest.TestCase):
self.assertEqual(a + b, _a + b) self.assertEqual(a + b, _a + b)
# test repeat # test repeat
self.assert_(a*5 == _a*5) self.assertTrue(a*5 == _a*5)
def test_join(self): def test_join(self):
# Make sure join returns a NEW object for single item sequences # Make sure join returns a NEW object for single item sequences
@ -987,12 +987,12 @@ class ByteArraySubclassTest(unittest.TestCase):
# Make sure that it is of the appropriate type. # Make sure that it is of the appropriate type.
s1 = ByteArraySubclass(b"abcd") s1 = ByteArraySubclass(b"abcd")
s2 = bytearray().join([s1]) s2 = bytearray().join([s1])
self.assert_(s1 is not s2) self.assertTrue(s1 is not s2)
self.assert_(type(s2) is bytearray, type(s2)) self.assertTrue(type(s2) is bytearray, type(s2))
# Test reverse, calling join on subclass # Test reverse, calling join on subclass
s3 = s1.join([b"abcd"]) s3 = s1.join([b"abcd"])
self.assert_(type(s3) is bytearray) self.assertTrue(type(s3) is bytearray)
def test_pickle(self): def test_pickle(self):
a = ByteArraySubclass(b"abcd") a = ByteArraySubclass(b"abcd")

2
Lib/test/test_capi.py
View file

@ -41,7 +41,7 @@ class TestPendingCalls(unittest.TestCase):
if context and not context.event.is_set(): if context and not context.event.is_set():
continue continue
count += 1 count += 1
self.failUnless(count < 10000, self.assertTrue(count < 10000,
"timeout waiting for %i callbacks, got %i"%(n, len(l))) "timeout waiting for %i callbacks, got %i"%(n, len(l)))
if False and test_support.verbose: if False and test_support.verbose:
print "(%i)"%(len(l),) print "(%i)"%(len(l),)

20
Lib/test/test_cfgparser.py
View file

@ -81,16 +81,16 @@ class TestCaseBase(unittest.TestCase):
eq(cf.get('Spaces', 'key with spaces'), 'value') eq(cf.get('Spaces', 'key with spaces'), 'value')
eq(cf.get('Spaces', 'another with spaces'), 'splat!') eq(cf.get('Spaces', 'another with spaces'), 'splat!')
self.failIf('__name__' in cf.options("Foo Bar"), self.assertFalse('__name__' in cf.options("Foo Bar"),
'__name__ "option" should not be exposed by the API!') '__name__ "option" should not be exposed by the API!')
# Make sure the right things happen for remove_option(); # Make sure the right things happen for remove_option();
# added to include check for SourceForge bug #123324: # added to include check for SourceForge bug #123324:
self.failUnless(cf.remove_option('Foo Bar', 'foo'), self.assertTrue(cf.remove_option('Foo Bar', 'foo'),
"remove_option() failed to report existence of option") "remove_option() failed to report existence of option")
self.failIf(cf.has_option('Foo Bar', 'foo'), self.assertFalse(cf.has_option('Foo Bar', 'foo'),
"remove_option() failed to remove option") "remove_option() failed to remove option")
self.failIf(cf.remove_option('Foo Bar', 'foo'), self.assertFalse(cf.remove_option('Foo Bar', 'foo'),
"remove_option() failed to report non-existence of option" "remove_option() failed to report non-existence of option"
" that was removed") " that was removed")
@ -112,10 +112,10 @@ class TestCaseBase(unittest.TestCase):
eq(cf.options("a"), ["b"]) eq(cf.options("a"), ["b"])
eq(cf.get("a", "b"), "value", eq(cf.get("a", "b"), "value",
"could not locate option, expecting case-insensitive option names") "could not locate option, expecting case-insensitive option names")
self.failUnless(cf.has_option("a", "b")) self.assertTrue(cf.has_option("a", "b"))
cf.set("A", "A-B", "A-B value") cf.set("A", "A-B", "A-B value")
for opt in ("a-b", "A-b", "a-B", "A-B"): for opt in ("a-b", "A-b", "a-B", "A-B"):
self.failUnless( self.assertTrue(
cf.has_option("A", opt), cf.has_option("A", opt),
"has_option() returned false for option which should exist") "has_option() returned false for option which should exist")
eq(cf.options("A"), ["a-b"]) eq(cf.options("A"), ["a-b"])
@ -132,7 +132,7 @@ class TestCaseBase(unittest.TestCase):
# SF bug #561822: # SF bug #561822:
cf = self.fromstring("[section]\nnekey=nevalue\n", cf = self.fromstring("[section]\nnekey=nevalue\n",
defaults={"key":"value"}) defaults={"key":"value"})
self.failUnless(cf.has_option("section", "Key")) self.assertTrue(cf.has_option("section", "Key"))
def test_default_case_sensitivity(self): def test_default_case_sensitivity(self):
@ -168,7 +168,7 @@ class TestCaseBase(unittest.TestCase):
cf = self.newconfig() cf = self.newconfig()
self.assertEqual(cf.sections(), [], self.assertEqual(cf.sections(), [],
"new ConfigParser should have no defined sections") "new ConfigParser should have no defined sections")
self.failIf(cf.has_section("Foo"), self.assertFalse(cf.has_section("Foo"),
"new ConfigParser should have no acknowledged sections") "new ConfigParser should have no acknowledged sections")
self.assertRaises(ConfigParser.NoSectionError, self.assertRaises(ConfigParser.NoSectionError,
cf.options, "Foo") cf.options, "Foo")
@ -207,8 +207,8 @@ class TestCaseBase(unittest.TestCase):
"E5=FALSE AND MORE" "E5=FALSE AND MORE"
) )
for x in range(1, 5): for x in range(1, 5):
self.failUnless(cf.getboolean('BOOLTEST', 't%d' % x)) self.assertTrue(cf.getboolean('BOOLTEST', 't%d' % x))
self.failIf(cf.getboolean('BOOLTEST', 'f%d' % x)) self.assertFalse(cf.getboolean('BOOLTEST', 'f%d' % x))
self.assertRaises(ValueError, self.assertRaises(ValueError,
cf.getboolean, 'BOOLTEST', 'e%d' % x) cf.getboolean, 'BOOLTEST', 'e%d' % x)

10
Lib/test/test_cgi.py
View file

@ -151,10 +151,10 @@ class CgiTests(unittest.TestCase):
# test individual fields # test individual fields
for key in expect.keys(): for key in expect.keys():
expect_val = expect[key] expect_val = expect[key]
self.assert_(fcd.has_key(key)) self.assertTrue(fcd.has_key(key))
self.assertEqual(norm(fcd[key]), norm(expect[key])) self.assertEqual(norm(fcd[key]), norm(expect[key]))
self.assertEqual(fcd.get(key, "default"), fcd[key]) self.assertEqual(fcd.get(key, "default"), fcd[key])
self.assert_(fs.has_key(key)) self.assertTrue(fs.has_key(key))
if len(expect_val) > 1: if len(expect_val) > 1:
single_value = 0 single_value = 0
else: else:
@ -162,10 +162,10 @@ class CgiTests(unittest.TestCase):
try: try:
val = sd[key] val = sd[key]
except IndexError: except IndexError:
self.failIf(single_value) self.assertFalse(single_value)
self.assertEqual(fs.getvalue(key), expect_val) self.assertEqual(fs.getvalue(key), expect_val)
else: else:
self.assert_(single_value) self.assertTrue(single_value)
self.assertEqual(val, expect_val[0]) self.assertEqual(val, expect_val[0])
self.assertEqual(fs.getvalue(key), expect_val[0]) self.assertEqual(fs.getvalue(key), expect_val[0])
self.assertEqual(norm(sd.getlist(key)), norm(expect_val)) self.assertEqual(norm(sd.getlist(key)), norm(expect_val))
@ -231,7 +231,7 @@ class CgiTests(unittest.TestCase):
# if we're not chunking properly, readline is only called twice # if we're not chunking properly, readline is only called twice
# (by read_binary); if we are chunking properly, it will be called 5 times # (by read_binary); if we are chunking properly, it will be called 5 times
# as long as the chunksize is 1 << 16. # as long as the chunksize is 1 << 16.
self.assert_(f.numcalls > 2) self.assertTrue(f.numcalls > 2)
def test_fieldstorage_multipart(self): def test_fieldstorage_multipart(self):
#Test basic FieldStorage multipart parsing #Test basic FieldStorage multipart parsing

56
Lib/test/test_cmath.py
View file

@ -416,7 +416,7 @@ class CMathTests(unittest.TestCase):
# real or imaginary part NaN # real or imaginary part NaN
for z in complex_nans: for z in complex_nans:
self.assert_(math.isnan(phase(z))) self.assertTrue(math.isnan(phase(z)))
def test_abs(self): def test_abs(self):
# zeros # zeros
@ -429,18 +429,18 @@ class CMathTests(unittest.TestCase):
# real or imaginary part NaN # real or imaginary part NaN
self.assertEqual(abs(complex(NAN, -INF)), INF) self.assertEqual(abs(complex(NAN, -INF)), INF)
self.assert_(math.isnan(abs(complex(NAN, -2.3)))) self.assertTrue(math.isnan(abs(complex(NAN, -2.3))))
self.assert_(math.isnan(abs(complex(NAN, -0.0)))) self.assertTrue(math.isnan(abs(complex(NAN, -0.0))))
self.assert_(math.isnan(abs(complex(NAN, 0.0)))) self.assertTrue(math.isnan(abs(complex(NAN, 0.0))))
self.assert_(math.isnan(abs(complex(NAN, 2.3)))) self.assertTrue(math.isnan(abs(complex(NAN, 2.3))))
self.assertEqual(abs(complex(NAN, INF)), INF) self.assertEqual(abs(complex(NAN, INF)), INF)
self.assertEqual(abs(complex(-INF, NAN)), INF) self.assertEqual(abs(complex(-INF, NAN)), INF)
self.assert_(math.isnan(abs(complex(-2.3, NAN)))) self.assertTrue(math.isnan(abs(complex(-2.3, NAN))))
self.assert_(math.isnan(abs(complex(-0.0, NAN)))) self.assertTrue(math.isnan(abs(complex(-0.0, NAN))))
self.assert_(math.isnan(abs(complex(0.0, NAN)))) self.assertTrue(math.isnan(abs(complex(0.0, NAN))))
self.assert_(math.isnan(abs(complex(2.3, NAN)))) self.assertTrue(math.isnan(abs(complex(2.3, NAN))))
self.assertEqual(abs(complex(INF, NAN)), INF) self.assertEqual(abs(complex(INF, NAN)), INF)
self.assert_(math.isnan(abs(complex(NAN, NAN)))) self.assertTrue(math.isnan(abs(complex(NAN, NAN))))
# result overflows # result overflows
if float.__getformat__("double").startswith("IEEE"): if float.__getformat__("double").startswith("IEEE"):
@ -459,26 +459,26 @@ class CMathTests(unittest.TestCase):
self.assertCEqual(rect(1, -pi/2), (0, -1.)) self.assertCEqual(rect(1, -pi/2), (0, -1.))
def test_isnan(self): def test_isnan(self):
self.failIf(cmath.isnan(1)) self.assertFalse(cmath.isnan(1))
self.failIf(cmath.isnan(1j)) self.assertFalse(cmath.isnan(1j))
self.failIf(cmath.isnan(INF)) self.assertFalse(cmath.isnan(INF))
self.assert_(cmath.isnan(NAN)) self.assertTrue(cmath.isnan(NAN))
self.assert_(cmath.isnan(complex(NAN, 0))) self.assertTrue(cmath.isnan(complex(NAN, 0)))
self.assert_(cmath.isnan(complex(0, NAN))) self.assertTrue(cmath.isnan(complex(0, NAN)))
self.assert_(cmath.isnan(complex(NAN, NAN))) self.assertTrue(cmath.isnan(complex(NAN, NAN)))
self.assert_(cmath.isnan(complex(NAN, INF))) self.assertTrue(cmath.isnan(complex(NAN, INF)))
self.assert_(cmath.isnan(complex(INF, NAN))) self.assertTrue(cmath.isnan(complex(INF, NAN)))
def test_isinf(self): def test_isinf(self):
self.failIf(cmath.isinf(1)) self.assertFalse(cmath.isinf(1))
self.failIf(cmath.isinf(1j)) self.assertFalse(cmath.isinf(1j))
self.failIf(cmath.isinf(NAN)) self.assertFalse(cmath.isinf(NAN))
self.assert_(cmath.isinf(INF)) self.assertTrue(cmath.isinf(INF))
self.assert_(cmath.isinf(complex(INF, 0))) self.assertTrue(cmath.isinf(complex(INF, 0)))
self.assert_(cmath.isinf(complex(0, INF))) self.assertTrue(cmath.isinf(complex(0, INF)))
self.assert_(cmath.isinf(complex(INF, INF))) self.assertTrue(cmath.isinf(complex(INF, INF)))
self.assert_(cmath.isinf(complex(NAN, INF))) self.assertTrue(cmath.isinf(complex(NAN, INF)))
self.assert_(cmath.isinf(complex(INF, NAN))) self.assertTrue(cmath.isinf(complex(INF, NAN)))
def test_main(): def test_main():

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