mirror of
https://github.com/python/cpython
synced 2024-10-04 19:29:34 +00:00
convert old fail* assertions to assert*
This commit is contained in:
parent
98d23f2e06
commit
c9c0f201fe
|
@ -14,22 +14,22 @@ class Y(Structure):
|
|||
("y", c_int)]
|
||||
_anonymous_ = ["_"]
|
||||
|
||||
self.failUnlessEqual(Y.a.offset, sizeof(c_int))
|
||||
self.failUnlessEqual(Y.b.offset, sizeof(c_int))
|
||||
self.assertEqual(Y.a.offset, sizeof(c_int))
|
||||
self.assertEqual(Y.b.offset, sizeof(c_int))
|
||||
|
||||
self.failUnlessEqual(ANON.a.offset, 0)
|
||||
self.failUnlessEqual(ANON.b.offset, 0)
|
||||
self.assertEqual(ANON.a.offset, 0)
|
||||
self.assertEqual(ANON.b.offset, 0)
|
||||
|
||||
def test_anon_nonseq(self):
|
||||
# TypeError: _anonymous_ must be a sequence
|
||||
self.failUnlessRaises(TypeError,
|
||||
self.assertRaises(TypeError,
|
||||
lambda: type(Structure)("Name",
|
||||
(Structure,),
|
||||
{"_fields_": [], "_anonymous_": 42}))
|
||||
|
||||
def test_anon_nonmember(self):
|
||||
# AttributeError: type object 'Name' has no attribute 'x'
|
||||
self.failUnlessRaises(AttributeError,
|
||||
self.assertRaises(AttributeError,
|
||||
lambda: type(Structure)("Name",
|
||||
(Structure,),
|
||||
{"_fields_": [],
|
||||
|
@ -50,11 +50,11 @@ class Y(Structure):
|
|||
("y", c_int)]
|
||||
_anonymous_ = ["_"]
|
||||
|
||||
self.failUnlessEqual(Y.x.offset, 0)
|
||||
self.failUnlessEqual(Y.a.offset, sizeof(c_int))
|
||||
self.failUnlessEqual(Y.b.offset, sizeof(c_int))
|
||||
self.failUnlessEqual(Y._.offset, sizeof(c_int))
|
||||
self.failUnlessEqual(Y.y.offset, sizeof(c_int) * 2)
|
||||
self.assertEqual(Y.x.offset, 0)
|
||||
self.assertEqual(Y.a.offset, sizeof(c_int))
|
||||
self.assertEqual(Y.b.offset, sizeof(c_int))
|
||||
self.assertEqual(Y._.offset, sizeof(c_int))
|
||||
self.assertEqual(Y.y.offset, sizeof(c_int) * 2)
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -26,7 +26,7 @@ def test(self):
|
|||
c.pvalues = val_array
|
||||
|
||||
# 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:
|
||||
for i in range(4):
|
||||
|
@ -35,7 +35,7 @@ def test(self):
|
|||
values = [c.pvalues[i].val for i in range(4)]
|
||||
|
||||
# These are the expected results: here s the bug!
|
||||
self.failUnlessEqual(
|
||||
self.assertEqual(
|
||||
(values, dump(val_array)),
|
||||
([1, 2, 3, 4], "01-02-03-04")
|
||||
)
|
||||
|
@ -45,7 +45,7 @@ def test_2(self):
|
|||
val_array = (Value * 4)()
|
||||
|
||||
# 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))
|
||||
# set the values of the array through the pointer:
|
||||
|
@ -55,7 +55,7 @@ def test_2(self):
|
|||
values = [ptr[i].val for i in range(4)]
|
||||
|
||||
# These are the expected results: here s the bug!
|
||||
self.failUnlessEqual(
|
||||
self.assertEqual(
|
||||
(values, dump(val_array)),
|
||||
([1, 2, 3, 4], "01-02-03-04")
|
||||
)
|
||||
|
|
|
@ -19,23 +19,23 @@ def test_simple(self):
|
|||
|
||||
ia = int_array(*init)
|
||||
# length of instance ok?
|
||||
self.failUnlessEqual(len(ia), alen)
|
||||
self.assertEqual(len(ia), alen)
|
||||
|
||||
# slot values ok?
|
||||
values = [ia[i] for i in range(len(init))]
|
||||
self.failUnlessEqual(values, init)
|
||||
self.assertEqual(values, init)
|
||||
|
||||
# change the items
|
||||
from operator import setitem
|
||||
new_values = list(range(42, 42+alen))
|
||||
[setitem(ia, n, new_values[n]) for n in range(alen)]
|
||||
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?
|
||||
ia = int_array()
|
||||
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
|
||||
self.assertRaises(IndexError, int_array, *range(alen*2))
|
||||
|
@ -48,14 +48,14 @@ def test_simple(self):
|
|||
# CharArray("abc")
|
||||
self.assertRaises(TypeError, CharArray, "abc")
|
||||
|
||||
self.failUnlessEqual(ca[0], b"a")
|
||||
self.failUnlessEqual(ca[1], b"b")
|
||||
self.failUnlessEqual(ca[2], b"c")
|
||||
self.failUnlessEqual(ca[-3], b"a")
|
||||
self.failUnlessEqual(ca[-2], b"b")
|
||||
self.failUnlessEqual(ca[-1], b"c")
|
||||
self.assertEqual(ca[0], b"a")
|
||||
self.assertEqual(ca[1], b"b")
|
||||
self.assertEqual(ca[2], b"c")
|
||||
self.assertEqual(ca[-3], b"a")
|
||||
self.assertEqual(ca[-2], b"b")
|
||||
self.assertEqual(ca[-1], b"c")
|
||||
|
||||
self.failUnlessEqual(len(ca), 3)
|
||||
self.assertEqual(len(ca), 3)
|
||||
|
||||
# cannot delete items
|
||||
from operator import delitem
|
||||
|
@ -69,34 +69,34 @@ def test_numeric_arrays(self):
|
|||
|
||||
na = numarray()
|
||||
values = [na[i] for i in range(alen)]
|
||||
self.failUnlessEqual(values, [0] * alen)
|
||||
self.assertEqual(values, [0] * alen)
|
||||
|
||||
na = numarray(*[c_int()] * 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)
|
||||
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)))
|
||||
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):
|
||||
self.failUnless(not ARRAY(c_int, 3) is ARRAY(c_int, 4))
|
||||
self.failUnless(ARRAY(c_int, 3) is ARRAY(c_int, 3))
|
||||
self.assertTrue(not ARRAY(c_int, 3) is ARRAY(c_int, 4))
|
||||
self.assertTrue(ARRAY(c_int, 3) is ARRAY(c_int, 3))
|
||||
|
||||
def test_from_address(self):
|
||||
# Failed with 0.9.8, reported by JUrner
|
||||
p = create_string_buffer("foo")
|
||||
sz = (c_char * 3).from_address(addressof(p))
|
||||
self.failUnlessEqual(sz[:], b"foo")
|
||||
self.failUnlessEqual(sz[::], b"foo")
|
||||
self.failUnlessEqual(sz[::-1], b"oof")
|
||||
self.failUnlessEqual(sz[::3], b"f")
|
||||
self.failUnlessEqual(sz[1:4:2], b"o")
|
||||
self.failUnlessEqual(sz.value, b"foo")
|
||||
self.assertEqual(sz[:], b"foo")
|
||||
self.assertEqual(sz[::], b"foo")
|
||||
self.assertEqual(sz[::-1], b"oof")
|
||||
self.assertEqual(sz[::3], b"f")
|
||||
self.assertEqual(sz[1:4:2], b"o")
|
||||
self.assertEqual(sz.value, b"foo")
|
||||
|
||||
try:
|
||||
create_unicode_buffer
|
||||
|
@ -106,12 +106,12 @@ def test_from_address(self):
|
|||
def test_from_addressW(self):
|
||||
p = create_unicode_buffer("foo")
|
||||
sz = (c_wchar * 3).from_address(addressof(p))
|
||||
self.failUnlessEqual(sz[:], "foo")
|
||||
self.failUnlessEqual(sz[::], "foo")
|
||||
self.failUnlessEqual(sz[::-1], "oof")
|
||||
self.failUnlessEqual(sz[::3], "f")
|
||||
self.failUnlessEqual(sz[1:4:2], "o")
|
||||
self.failUnlessEqual(sz.value, "foo")
|
||||
self.assertEqual(sz[:], "foo")
|
||||
self.assertEqual(sz[::], "foo")
|
||||
self.assertEqual(sz[::-1], "oof")
|
||||
self.assertEqual(sz[::3], "f")
|
||||
self.assertEqual(sz[1:4:2], "o")
|
||||
self.assertEqual(sz.value, "foo")
|
||||
|
||||
def test_cache(self):
|
||||
# Array types are cached internally in the _ctypes extension,
|
||||
|
@ -125,7 +125,7 @@ class my_int(c_int):
|
|||
# Create a new array type based on it:
|
||||
t1 = my_int * 1
|
||||
t2 = my_int * 1
|
||||
self.failUnless(t1 is t2)
|
||||
self.assertTrue(t1 is t2)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
|
@ -25,8 +25,8 @@ def test_wchar_parm(self):
|
|||
f = dll._testfunc_i_bhilfd
|
||||
f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
|
||||
result = f(self.wrap(1), self.wrap("x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0))
|
||||
self.failUnlessEqual(result, 139)
|
||||
self.failUnless(type(result), int)
|
||||
self.assertEqual(result, 139)
|
||||
self.assertTrue(type(result), int)
|
||||
|
||||
def test_pointers(self):
|
||||
f = dll._testfunc_p_p
|
||||
|
@ -39,18 +39,18 @@ def test_pointers(self):
|
|||
|
||||
v = c_int(42)
|
||||
|
||||
self.failUnlessEqual(pointer(v).contents.value, 42)
|
||||
self.assertEqual(pointer(v).contents.value, 42)
|
||||
result = f(self.wrap(pointer(v)))
|
||||
self.failUnlessEqual(type(result), POINTER(c_int))
|
||||
self.failUnlessEqual(result.contents.value, 42)
|
||||
self.assertEqual(type(result), POINTER(c_int))
|
||||
self.assertEqual(result.contents.value, 42)
|
||||
|
||||
# This on works...
|
||||
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))
|
||||
result = f(self.wrap(p))
|
||||
self.failUnlessEqual(result.contents.value, 99)
|
||||
self.assertEqual(result.contents.value, 99)
|
||||
|
||||
def test_shorts(self):
|
||||
f = dll._testfunc_callback_i_if
|
||||
|
@ -67,7 +67,7 @@ def callback(v):
|
|||
|
||||
cb = CallBack(callback)
|
||||
f(self.wrap(2**18), self.wrap(cb))
|
||||
self.failUnlessEqual(args, expected)
|
||||
self.assertEqual(args, expected)
|
||||
|
||||
################################################################
|
||||
|
||||
|
@ -84,17 +84,17 @@ def callback(value):
|
|||
cb = MyCallback(callback)
|
||||
|
||||
result = f(self.wrap(-10), self.wrap(cb))
|
||||
self.failUnlessEqual(result, -18)
|
||||
self.assertEqual(result, -18)
|
||||
|
||||
# test with prototype
|
||||
f.argtypes = [c_int, MyCallback]
|
||||
cb = MyCallback(callback)
|
||||
|
||||
result = f(self.wrap(-10), self.wrap(cb))
|
||||
self.failUnlessEqual(result, -18)
|
||||
self.assertEqual(result, -18)
|
||||
|
||||
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)
|
||||
|
||||
|
@ -116,12 +116,12 @@ def test_callbacks_2(self):
|
|||
|
||||
def callback(value):
|
||||
#print "called back with", value
|
||||
self.failUnlessEqual(type(value), int)
|
||||
self.assertEqual(type(value), int)
|
||||
return value
|
||||
|
||||
cb = MyCallback(callback)
|
||||
result = f(self.wrap(-10), self.wrap(cb))
|
||||
self.failUnlessEqual(result, -18)
|
||||
self.assertEqual(result, -18)
|
||||
|
||||
def test_longlong_callbacks(self):
|
||||
|
||||
|
@ -133,12 +133,12 @@ def test_longlong_callbacks(self):
|
|||
f.argtypes = [c_longlong, MyCallback]
|
||||
|
||||
def callback(value):
|
||||
self.failUnless(isinstance(value, int))
|
||||
self.assertTrue(isinstance(value, int))
|
||||
return value & 0x7FFFFFFF
|
||||
|
||||
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):
|
||||
# without prototype
|
||||
|
@ -148,7 +148,7 @@ def test_byval(self):
|
|||
result = dll._testfunc_byval(ptin, byref(ptout))
|
||||
got = result, ptout.x, ptout.y
|
||||
expected = 3, 1, 2
|
||||
self.failUnlessEqual(got, expected)
|
||||
self.assertEqual(got, expected)
|
||||
|
||||
# with prototype
|
||||
ptin = POINT(101, 102)
|
||||
|
@ -158,7 +158,7 @@ def test_byval(self):
|
|||
result = dll._testfunc_byval(self.wrap(ptin), byref(ptout))
|
||||
got = result, ptout.x, ptout.y
|
||||
expected = 203, 101, 102
|
||||
self.failUnlessEqual(got, expected)
|
||||
self.assertEqual(got, expected)
|
||||
|
||||
def test_struct_return_2H(self):
|
||||
class S2H(Structure):
|
||||
|
@ -168,7 +168,7 @@ class S2H(Structure):
|
|||
dll.ret_2h_func.argtypes = [S2H]
|
||||
inp = S2H(99, 88)
|
||||
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):
|
||||
class S8I(Structure):
|
||||
|
@ -184,7 +184,7 @@ class S8I(Structure):
|
|||
dll.ret_8i_func.argtypes = [S8I]
|
||||
inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
|
||||
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))
|
||||
|
||||
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
|
|
@ -37,14 +37,14 @@ def test_ints(self):
|
|||
for name in "ABCDEFGHI":
|
||||
b = BITS()
|
||||
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):
|
||||
for i in range(256):
|
||||
for name in "MNOPQRS":
|
||||
b = BITS()
|
||||
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)
|
||||
unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
|
||||
|
@ -58,10 +58,10 @@ class X(Structure):
|
|||
("b", c_longlong, 62),
|
||||
("c", c_longlong, 1)]
|
||||
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_longlong))
|
||||
self.assertEqual(sizeof(X), sizeof(c_longlong))
|
||||
x = X()
|
||||
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):
|
||||
class X(Structure):
|
||||
|
@ -69,11 +69,11 @@ class X(Structure):
|
|||
("b", c_ulonglong, 62),
|
||||
("c", c_ulonglong, 1)]
|
||||
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_longlong))
|
||||
self.assertEqual(sizeof(X), sizeof(c_longlong))
|
||||
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
|
||||
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):
|
||||
for c_typ in signed_int_types:
|
||||
|
@ -82,14 +82,14 @@ class X(Structure):
|
|||
("a", c_typ, 3),
|
||||
("b", c_typ, 3),
|
||||
("c", c_typ, 1)]
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_typ)*2)
|
||||
self.assertEqual(sizeof(X), sizeof(c_typ)*2)
|
||||
|
||||
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
|
||||
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
|
||||
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):
|
||||
|
@ -98,14 +98,14 @@ class X(Structure):
|
|||
_fields_ = [("a", c_typ, 3),
|
||||
("b", c_typ, 3),
|
||||
("c", c_typ, 1)]
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_typ))
|
||||
self.assertEqual(sizeof(X), sizeof(c_typ))
|
||||
|
||||
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
|
||||
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
|
||||
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):
|
||||
|
@ -115,17 +115,17 @@ def fail_fields(self, *fields):
|
|||
def test_nonint_types(self):
|
||||
# bit fields are not allowed on non-integer types.
|
||||
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))
|
||||
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:
|
||||
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))
|
||||
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:
|
||||
c_wchar
|
||||
|
@ -133,59 +133,59 @@ def test_nonint_types(self):
|
|||
pass
|
||||
else:
|
||||
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):
|
||||
_fields_ = []
|
||||
|
||||
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):
|
||||
for c_typ in int_types:
|
||||
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))
|
||||
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):
|
||||
_fields_ = [("a", c_typ, 1)]
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_typ))
|
||||
self.assertEqual(sizeof(X), sizeof(c_typ))
|
||||
|
||||
class X(Structure):
|
||||
_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))
|
||||
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):
|
||||
class X(Structure):
|
||||
_fields_ = [("a", c_short, 1),
|
||||
("b", c_short, 14),
|
||||
("c", c_short, 1)]
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_short))
|
||||
self.assertEqual(sizeof(X), sizeof(c_short))
|
||||
|
||||
class X(Structure):
|
||||
_fields_ = [("a", c_short, 1),
|
||||
("a1", c_short),
|
||||
("b", c_short, 14),
|
||||
("c", c_short, 1)]
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_short)*3)
|
||||
self.failUnlessEqual(X.a.offset, 0)
|
||||
self.failUnlessEqual(X.a1.offset, sizeof(c_short))
|
||||
self.failUnlessEqual(X.b.offset, sizeof(c_short)*2)
|
||||
self.failUnlessEqual(X.c.offset, sizeof(c_short)*2)
|
||||
self.assertEqual(sizeof(X), sizeof(c_short)*3)
|
||||
self.assertEqual(X.a.offset, 0)
|
||||
self.assertEqual(X.a1.offset, sizeof(c_short))
|
||||
self.assertEqual(X.b.offset, sizeof(c_short)*2)
|
||||
self.assertEqual(X.c.offset, sizeof(c_short)*2)
|
||||
|
||||
class X(Structure):
|
||||
_fields_ = [("a", c_short, 3),
|
||||
("b", c_short, 14),
|
||||
("c", c_short, 14)]
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_short)*3)
|
||||
self.failUnlessEqual(X.a.offset, sizeof(c_short)*0)
|
||||
self.failUnlessEqual(X.b.offset, sizeof(c_short)*1)
|
||||
self.failUnlessEqual(X.c.offset, sizeof(c_short)*2)
|
||||
self.assertEqual(sizeof(X), sizeof(c_short)*3)
|
||||
self.assertEqual(X.a.offset, sizeof(c_short)*0)
|
||||
self.assertEqual(X.b.offset, sizeof(c_short)*1)
|
||||
self.assertEqual(X.c.offset, sizeof(c_short)*2)
|
||||
|
||||
|
||||
def get_except(self, func, *args, **kw):
|
||||
|
@ -199,21 +199,21 @@ class X(Structure):
|
|||
_fields_ = [("a", c_byte, 4),
|
||||
("b", c_int, 4)]
|
||||
if os.name in ("nt", "ce"):
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_int)*2)
|
||||
self.assertEqual(sizeof(X), sizeof(c_int)*2)
|
||||
else:
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_int))
|
||||
self.assertEqual(sizeof(X), sizeof(c_int))
|
||||
|
||||
def test_mixed_2(self):
|
||||
class X(Structure):
|
||||
_fields_ = [("a", c_byte, 4),
|
||||
("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):
|
||||
class X(Structure):
|
||||
_fields_ = [("a", c_byte, 4),
|
||||
("b", c_ubyte, 4)]
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_byte))
|
||||
self.assertEqual(sizeof(X), sizeof(c_byte))
|
||||
|
||||
def test_mixed_4(self):
|
||||
class X(Structure):
|
||||
|
@ -227,9 +227,9 @@ class X(Structure):
|
|||
# does (unless GCC is run with '-mms-bitfields' which
|
||||
# produces code compatible with MSVC).
|
||||
if os.name in ("nt", "ce"):
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_int) * 4)
|
||||
self.assertEqual(sizeof(X), sizeof(c_int) * 4)
|
||||
else:
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_int) * 2)
|
||||
self.assertEqual(sizeof(X), sizeof(c_int) * 2)
|
||||
|
||||
def test_anon_bitfields(self):
|
||||
# anonymous bit-fields gave a strange error message
|
||||
|
|
|
@ -5,32 +5,32 @@ class StringBufferTestCase(unittest.TestCase):
|
|||
|
||||
def test_buffer(self):
|
||||
b = create_string_buffer(32)
|
||||
self.failUnlessEqual(len(b), 32)
|
||||
self.failUnlessEqual(sizeof(b), 32 * sizeof(c_char))
|
||||
self.failUnless(type(b[0]) is bytes)
|
||||
self.assertEqual(len(b), 32)
|
||||
self.assertEqual(sizeof(b), 32 * sizeof(c_char))
|
||||
self.assertTrue(type(b[0]) is bytes)
|
||||
|
||||
b = create_string_buffer("abc")
|
||||
self.failUnlessEqual(len(b), 4) # trailing nul char
|
||||
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char))
|
||||
self.failUnless(type(b[0]) is bytes)
|
||||
self.failUnlessEqual(b[0], b"a")
|
||||
self.failUnlessEqual(b[:], b"abc\0")
|
||||
self.failUnlessEqual(b[::], b"abc\0")
|
||||
self.failUnlessEqual(b[::-1], b"\0cba")
|
||||
self.failUnlessEqual(b[::2], b"ac")
|
||||
self.failUnlessEqual(b[::5], b"a")
|
||||
self.assertEqual(len(b), 4) # trailing nul char
|
||||
self.assertEqual(sizeof(b), 4 * sizeof(c_char))
|
||||
self.assertTrue(type(b[0]) is bytes)
|
||||
self.assertEqual(b[0], b"a")
|
||||
self.assertEqual(b[:], b"abc\0")
|
||||
self.assertEqual(b[::], b"abc\0")
|
||||
self.assertEqual(b[::-1], b"\0cba")
|
||||
self.assertEqual(b[::2], b"ac")
|
||||
self.assertEqual(b[::5], b"a")
|
||||
|
||||
def test_string_conversion(self):
|
||||
b = create_string_buffer("abc")
|
||||
self.failUnlessEqual(len(b), 4) # trailing nul char
|
||||
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char))
|
||||
self.failUnless(type(b[0]) is bytes)
|
||||
self.failUnlessEqual(b[0], b"a")
|
||||
self.failUnlessEqual(b[:], b"abc\0")
|
||||
self.failUnlessEqual(b[::], b"abc\0")
|
||||
self.failUnlessEqual(b[::-1], b"\0cba")
|
||||
self.failUnlessEqual(b[::2], b"ac")
|
||||
self.failUnlessEqual(b[::5], b"a")
|
||||
self.assertEqual(len(b), 4) # trailing nul char
|
||||
self.assertEqual(sizeof(b), 4 * sizeof(c_char))
|
||||
self.assertTrue(type(b[0]) is bytes)
|
||||
self.assertEqual(b[0], b"a")
|
||||
self.assertEqual(b[:], b"abc\0")
|
||||
self.assertEqual(b[::], b"abc\0")
|
||||
self.assertEqual(b[::-1], b"\0cba")
|
||||
self.assertEqual(b[::2], b"ac")
|
||||
self.assertEqual(b[::5], b"a")
|
||||
|
||||
try:
|
||||
c_wchar
|
||||
|
@ -39,32 +39,32 @@ def test_string_conversion(self):
|
|||
else:
|
||||
def test_unicode_buffer(self):
|
||||
b = create_unicode_buffer(32)
|
||||
self.failUnlessEqual(len(b), 32)
|
||||
self.failUnlessEqual(sizeof(b), 32 * sizeof(c_wchar))
|
||||
self.failUnless(type(b[0]) is str)
|
||||
self.assertEqual(len(b), 32)
|
||||
self.assertEqual(sizeof(b), 32 * sizeof(c_wchar))
|
||||
self.assertTrue(type(b[0]) is str)
|
||||
|
||||
b = create_unicode_buffer("abc")
|
||||
self.failUnlessEqual(len(b), 4) # trailing nul char
|
||||
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_wchar))
|
||||
self.failUnless(type(b[0]) is str)
|
||||
self.failUnlessEqual(b[0], "a")
|
||||
self.failUnlessEqual(b[:], "abc\0")
|
||||
self.failUnlessEqual(b[::], "abc\0")
|
||||
self.failUnlessEqual(b[::-1], "\0cba")
|
||||
self.failUnlessEqual(b[::2], "ac")
|
||||
self.failUnlessEqual(b[::5], "a")
|
||||
self.assertEqual(len(b), 4) # trailing nul char
|
||||
self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
|
||||
self.assertTrue(type(b[0]) is str)
|
||||
self.assertEqual(b[0], "a")
|
||||
self.assertEqual(b[:], "abc\0")
|
||||
self.assertEqual(b[::], "abc\0")
|
||||
self.assertEqual(b[::-1], "\0cba")
|
||||
self.assertEqual(b[::2], "ac")
|
||||
self.assertEqual(b[::5], "a")
|
||||
|
||||
def test_unicode_conversion(self):
|
||||
b = create_unicode_buffer("abc")
|
||||
self.failUnlessEqual(len(b), 4) # trailing nul char
|
||||
self.failUnlessEqual(sizeof(b), 4 * sizeof(c_wchar))
|
||||
self.failUnless(type(b[0]) is str)
|
||||
self.failUnlessEqual(b[0], "a")
|
||||
self.failUnlessEqual(b[:], "abc\0")
|
||||
self.failUnlessEqual(b[::], "abc\0")
|
||||
self.failUnlessEqual(b[::-1], "\0cba")
|
||||
self.failUnlessEqual(b[::2], "ac")
|
||||
self.failUnlessEqual(b[::5], "a")
|
||||
self.assertEqual(len(b), 4) # trailing nul char
|
||||
self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
|
||||
self.assertTrue(type(b[0]) is str)
|
||||
self.assertEqual(b[0], "a")
|
||||
self.assertEqual(b[:], "abc\0")
|
||||
self.assertEqual(b[::], "abc\0")
|
||||
self.assertEqual(b[::-1], "\0cba")
|
||||
self.assertEqual(b[::2], "ac")
|
||||
self.assertEqual(b[::5], "a")
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -23,131 +23,131 @@ def X_test(self):
|
|||
|
||||
def test_endian_short(self):
|
||||
if sys.byteorder == "little":
|
||||
self.failUnless(c_short.__ctype_le__ is c_short)
|
||||
self.failUnless(c_short.__ctype_be__.__ctype_le__ is c_short)
|
||||
self.assertTrue(c_short.__ctype_le__ is c_short)
|
||||
self.assertTrue(c_short.__ctype_be__.__ctype_le__ is c_short)
|
||||
else:
|
||||
self.failUnless(c_short.__ctype_be__ is c_short)
|
||||
self.failUnless(c_short.__ctype_le__.__ctype_be__ is c_short)
|
||||
self.assertTrue(c_short.__ctype_be__ is c_short)
|
||||
self.assertTrue(c_short.__ctype_le__.__ctype_be__ is c_short)
|
||||
s = c_short.__ctype_be__(0x1234)
|
||||
self.failUnlessEqual(bin(struct.pack(">h", 0x1234)), "1234")
|
||||
self.failUnlessEqual(bin(s), "1234")
|
||||
self.failUnlessEqual(s.value, 0x1234)
|
||||
self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
|
||||
self.assertEqual(bin(s), "1234")
|
||||
self.assertEqual(s.value, 0x1234)
|
||||
|
||||
s = c_short.__ctype_le__(0x1234)
|
||||
self.failUnlessEqual(bin(struct.pack("<h", 0x1234)), "3412")
|
||||
self.failUnlessEqual(bin(s), "3412")
|
||||
self.failUnlessEqual(s.value, 0x1234)
|
||||
self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
|
||||
self.assertEqual(bin(s), "3412")
|
||||
self.assertEqual(s.value, 0x1234)
|
||||
|
||||
s = c_ushort.__ctype_be__(0x1234)
|
||||
self.failUnlessEqual(bin(struct.pack(">h", 0x1234)), "1234")
|
||||
self.failUnlessEqual(bin(s), "1234")
|
||||
self.failUnlessEqual(s.value, 0x1234)
|
||||
self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
|
||||
self.assertEqual(bin(s), "1234")
|
||||
self.assertEqual(s.value, 0x1234)
|
||||
|
||||
s = c_ushort.__ctype_le__(0x1234)
|
||||
self.failUnlessEqual(bin(struct.pack("<h", 0x1234)), "3412")
|
||||
self.failUnlessEqual(bin(s), "3412")
|
||||
self.failUnlessEqual(s.value, 0x1234)
|
||||
self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
|
||||
self.assertEqual(bin(s), "3412")
|
||||
self.assertEqual(s.value, 0x1234)
|
||||
|
||||
def test_endian_int(self):
|
||||
if sys.byteorder == "little":
|
||||
self.failUnless(c_int.__ctype_le__ is c_int)
|
||||
self.failUnless(c_int.__ctype_be__.__ctype_le__ is c_int)
|
||||
self.assertTrue(c_int.__ctype_le__ is c_int)
|
||||
self.assertTrue(c_int.__ctype_be__.__ctype_le__ is c_int)
|
||||
else:
|
||||
self.failUnless(c_int.__ctype_be__ is c_int)
|
||||
self.failUnless(c_int.__ctype_le__.__ctype_be__ is c_int)
|
||||
self.assertTrue(c_int.__ctype_be__ is c_int)
|
||||
self.assertTrue(c_int.__ctype_le__.__ctype_be__ is c_int)
|
||||
|
||||
s = c_int.__ctype_be__(0x12345678)
|
||||
self.failUnlessEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
|
||||
self.failUnlessEqual(bin(s), "12345678")
|
||||
self.failUnlessEqual(s.value, 0x12345678)
|
||||
self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
|
||||
self.assertEqual(bin(s), "12345678")
|
||||
self.assertEqual(s.value, 0x12345678)
|
||||
|
||||
s = c_int.__ctype_le__(0x12345678)
|
||||
self.failUnlessEqual(bin(struct.pack("<i", 0x12345678)), "78563412")
|
||||
self.failUnlessEqual(bin(s), "78563412")
|
||||
self.failUnlessEqual(s.value, 0x12345678)
|
||||
self.assertEqual(bin(struct.pack("<i", 0x12345678)), "78563412")
|
||||
self.assertEqual(bin(s), "78563412")
|
||||
self.assertEqual(s.value, 0x12345678)
|
||||
|
||||
s = c_uint.__ctype_be__(0x12345678)
|
||||
self.failUnlessEqual(bin(struct.pack(">I", 0x12345678)), "12345678")
|
||||
self.failUnlessEqual(bin(s), "12345678")
|
||||
self.failUnlessEqual(s.value, 0x12345678)
|
||||
self.assertEqual(bin(struct.pack(">I", 0x12345678)), "12345678")
|
||||
self.assertEqual(bin(s), "12345678")
|
||||
self.assertEqual(s.value, 0x12345678)
|
||||
|
||||
s = c_uint.__ctype_le__(0x12345678)
|
||||
self.failUnlessEqual(bin(struct.pack("<I", 0x12345678)), "78563412")
|
||||
self.failUnlessEqual(bin(s), "78563412")
|
||||
self.failUnlessEqual(s.value, 0x12345678)
|
||||
self.assertEqual(bin(struct.pack("<I", 0x12345678)), "78563412")
|
||||
self.assertEqual(bin(s), "78563412")
|
||||
self.assertEqual(s.value, 0x12345678)
|
||||
|
||||
def test_endian_longlong(self):
|
||||
if sys.byteorder == "little":
|
||||
self.failUnless(c_longlong.__ctype_le__ is c_longlong)
|
||||
self.failUnless(c_longlong.__ctype_be__.__ctype_le__ is c_longlong)
|
||||
self.assertTrue(c_longlong.__ctype_le__ is c_longlong)
|
||||
self.assertTrue(c_longlong.__ctype_be__.__ctype_le__ is c_longlong)
|
||||
else:
|
||||
self.failUnless(c_longlong.__ctype_be__ is c_longlong)
|
||||
self.failUnless(c_longlong.__ctype_le__.__ctype_be__ is c_longlong)
|
||||
self.assertTrue(c_longlong.__ctype_be__ is c_longlong)
|
||||
self.assertTrue(c_longlong.__ctype_le__.__ctype_be__ is c_longlong)
|
||||
|
||||
s = c_longlong.__ctype_be__(0x1234567890ABCDEF)
|
||||
self.failUnlessEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
|
||||
self.failUnlessEqual(bin(s), "1234567890ABCDEF")
|
||||
self.failUnlessEqual(s.value, 0x1234567890ABCDEF)
|
||||
self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
|
||||
self.assertEqual(bin(s), "1234567890ABCDEF")
|
||||
self.assertEqual(s.value, 0x1234567890ABCDEF)
|
||||
|
||||
s = c_longlong.__ctype_le__(0x1234567890ABCDEF)
|
||||
self.failUnlessEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
|
||||
self.failUnlessEqual(bin(s), "EFCDAB9078563412")
|
||||
self.failUnlessEqual(s.value, 0x1234567890ABCDEF)
|
||||
self.assertEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
|
||||
self.assertEqual(bin(s), "EFCDAB9078563412")
|
||||
self.assertEqual(s.value, 0x1234567890ABCDEF)
|
||||
|
||||
s = c_ulonglong.__ctype_be__(0x1234567890ABCDEF)
|
||||
self.failUnlessEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
|
||||
self.failUnlessEqual(bin(s), "1234567890ABCDEF")
|
||||
self.failUnlessEqual(s.value, 0x1234567890ABCDEF)
|
||||
self.assertEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
|
||||
self.assertEqual(bin(s), "1234567890ABCDEF")
|
||||
self.assertEqual(s.value, 0x1234567890ABCDEF)
|
||||
|
||||
s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF)
|
||||
self.failUnlessEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
|
||||
self.failUnlessEqual(bin(s), "EFCDAB9078563412")
|
||||
self.failUnlessEqual(s.value, 0x1234567890ABCDEF)
|
||||
self.assertEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
|
||||
self.assertEqual(bin(s), "EFCDAB9078563412")
|
||||
self.assertEqual(s.value, 0x1234567890ABCDEF)
|
||||
|
||||
def test_endian_float(self):
|
||||
if sys.byteorder == "little":
|
||||
self.failUnless(c_float.__ctype_le__ is c_float)
|
||||
self.failUnless(c_float.__ctype_be__.__ctype_le__ is c_float)
|
||||
self.assertTrue(c_float.__ctype_le__ is c_float)
|
||||
self.assertTrue(c_float.__ctype_be__.__ctype_le__ is c_float)
|
||||
else:
|
||||
self.failUnless(c_float.__ctype_be__ is c_float)
|
||||
self.failUnless(c_float.__ctype_le__.__ctype_be__ is c_float)
|
||||
self.assertTrue(c_float.__ctype_be__ is c_float)
|
||||
self.assertTrue(c_float.__ctype_le__.__ctype_be__ is c_float)
|
||||
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?
|
||||
self.failUnlessAlmostEqual(s.value, math.pi, places=6)
|
||||
self.assertAlmostEqual(s.value, math.pi, places=6)
|
||||
s = c_float.__ctype_le__(math.pi)
|
||||
self.failUnlessAlmostEqual(s.value, math.pi, places=6)
|
||||
self.failUnlessEqual(bin(struct.pack("<f", math.pi)), bin(s))
|
||||
self.assertAlmostEqual(s.value, math.pi, places=6)
|
||||
self.assertEqual(bin(struct.pack("<f", math.pi)), bin(s))
|
||||
s = c_float.__ctype_be__(math.pi)
|
||||
self.failUnlessAlmostEqual(s.value, math.pi, places=6)
|
||||
self.failUnlessEqual(bin(struct.pack(">f", math.pi)), bin(s))
|
||||
self.assertAlmostEqual(s.value, math.pi, places=6)
|
||||
self.assertEqual(bin(struct.pack(">f", math.pi)), bin(s))
|
||||
|
||||
def test_endian_double(self):
|
||||
if sys.byteorder == "little":
|
||||
self.failUnless(c_double.__ctype_le__ is c_double)
|
||||
self.failUnless(c_double.__ctype_be__.__ctype_le__ is c_double)
|
||||
self.assertTrue(c_double.__ctype_le__ is c_double)
|
||||
self.assertTrue(c_double.__ctype_be__.__ctype_le__ is c_double)
|
||||
else:
|
||||
self.failUnless(c_double.__ctype_be__ is c_double)
|
||||
self.failUnless(c_double.__ctype_le__.__ctype_be__ is c_double)
|
||||
self.assertTrue(c_double.__ctype_be__ is c_double)
|
||||
self.assertTrue(c_double.__ctype_le__.__ctype_be__ is c_double)
|
||||
s = c_double(math.pi)
|
||||
self.failUnlessEqual(s.value, math.pi)
|
||||
self.failUnlessEqual(bin(struct.pack("d", math.pi)), bin(s))
|
||||
self.assertEqual(s.value, math.pi)
|
||||
self.assertEqual(bin(struct.pack("d", math.pi)), bin(s))
|
||||
s = c_double.__ctype_le__(math.pi)
|
||||
self.failUnlessEqual(s.value, math.pi)
|
||||
self.failUnlessEqual(bin(struct.pack("<d", math.pi)), bin(s))
|
||||
self.assertEqual(s.value, math.pi)
|
||||
self.assertEqual(bin(struct.pack("<d", math.pi)), bin(s))
|
||||
s = c_double.__ctype_be__(math.pi)
|
||||
self.failUnlessEqual(s.value, math.pi)
|
||||
self.failUnlessEqual(bin(struct.pack(">d", math.pi)), bin(s))
|
||||
self.assertEqual(s.value, math.pi)
|
||||
self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
|
||||
|
||||
def test_endian_other(self):
|
||||
self.failUnless(c_byte.__ctype_le__ is c_byte)
|
||||
self.failUnless(c_byte.__ctype_be__ is c_byte)
|
||||
self.assertTrue(c_byte.__ctype_le__ is c_byte)
|
||||
self.assertTrue(c_byte.__ctype_be__ is c_byte)
|
||||
|
||||
self.failUnless(c_ubyte.__ctype_le__ is c_ubyte)
|
||||
self.failUnless(c_ubyte.__ctype_be__ is c_ubyte)
|
||||
self.assertTrue(c_ubyte.__ctype_le__ is c_ubyte)
|
||||
self.assertTrue(c_ubyte.__ctype_be__ is c_ubyte)
|
||||
|
||||
self.failUnless(c_char.__ctype_le__ is c_char)
|
||||
self.failUnless(c_char.__ctype_be__ is c_char)
|
||||
self.assertTrue(c_char.__ctype_le__ is c_char)
|
||||
self.assertTrue(c_char.__ctype_be__ is c_char)
|
||||
|
||||
def test_struct_fields_1(self):
|
||||
if sys.byteorder == "little":
|
||||
|
@ -219,7 +219,7 @@ class S(base):
|
|||
|
||||
s1 = S(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):
|
||||
if sys.byteorder == "little":
|
||||
|
@ -247,7 +247,7 @@ class S(base):
|
|||
s1.i = 0x12345678
|
||||
s1.d = 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):
|
||||
if sys.byteorder == "little":
|
||||
|
@ -274,7 +274,7 @@ class S(Structure):
|
|||
s1.i = 0x12345678
|
||||
s1.d = 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__":
|
||||
unittest.main()
|
||||
|
|
|
@ -17,18 +17,18 @@ def check_type(self, typ, arg):
|
|||
PROTO = self.functype.__func__(typ, typ)
|
||||
result = PROTO(self.callback)(arg)
|
||||
if typ == c_float:
|
||||
self.failUnlessAlmostEqual(result, arg, places=5)
|
||||
self.assertAlmostEqual(result, arg, places=5)
|
||||
else:
|
||||
self.failUnlessEqual(self.got_args, (arg,))
|
||||
self.failUnlessEqual(result, arg)
|
||||
self.assertEqual(self.got_args, (arg,))
|
||||
self.assertEqual(result, arg)
|
||||
|
||||
PROTO = self.functype.__func__(typ, c_byte, typ)
|
||||
result = PROTO(self.callback)(-3, arg)
|
||||
if typ == c_float:
|
||||
self.failUnlessAlmostEqual(result, arg, places=5)
|
||||
self.assertAlmostEqual(result, arg, places=5)
|
||||
else:
|
||||
self.failUnlessEqual(self.got_args, (-3, arg))
|
||||
self.failUnlessEqual(result, arg)
|
||||
self.assertEqual(self.got_args, (-3, arg))
|
||||
self.assertEqual(result, arg)
|
||||
|
||||
################
|
||||
|
||||
|
@ -103,7 +103,7 @@ def test_pyobject(self):
|
|||
# ...but this call doesn't leak any more. Where is the refcount?
|
||||
self.check_type(py_object, o)
|
||||
after = grc(o)
|
||||
self.failUnlessEqual((after, o), (before, o))
|
||||
self.assertEqual((after, o), (before, o))
|
||||
|
||||
def test_unsupported_restype_1(self):
|
||||
# Only "fundamental" result types are supported for callback
|
||||
|
@ -148,7 +148,7 @@ def func(x):
|
|||
result = integrate(0.0, 1.0, CALLBACK(func), 10)
|
||||
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)
|
||||
|
||||
################################################################
|
||||
|
||||
|
|
|
@ -9,15 +9,15 @@ def test_array2pointer(self):
|
|||
|
||||
# casting an array to a pointer works.
|
||||
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):
|
||||
ptr = cast(array, POINTER(c_short))
|
||||
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])
|
||||
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])
|
||||
|
||||
def test_address2pointer(self):
|
||||
|
@ -25,54 +25,54 @@ def test_address2pointer(self):
|
|||
|
||||
address = addressof(array)
|
||||
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))
|
||||
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):
|
||||
array = (c_char_p * 5)()
|
||||
self.failUnlessEqual(array._objects, None)
|
||||
self.assertEqual(array._objects, None)
|
||||
array[0] = "foo bar"
|
||||
self.failUnlessEqual(array._objects, {'0': b"foo bar"})
|
||||
self.assertEqual(array._objects, {'0': b"foo bar"})
|
||||
|
||||
p = cast(array, POINTER(c_char_p))
|
||||
# array and p share a common _objects attribute
|
||||
self.failUnless(p._objects is array._objects)
|
||||
self.failUnlessEqual(array._objects, {'0': b"foo bar", id(array): array})
|
||||
self.assertTrue(p._objects is array._objects)
|
||||
self.assertEqual(array._objects, {'0': b"foo bar", id(array): array})
|
||||
p[0] = "spam spam"
|
||||
self.failUnlessEqual(p._objects, {'0': b"spam spam", id(array): array})
|
||||
self.failUnless(array._objects is p._objects)
|
||||
self.assertEqual(p._objects, {'0': b"spam spam", id(array): array})
|
||||
self.assertTrue(array._objects is p._objects)
|
||||
p[1] = "foo bar"
|
||||
self.failUnlessEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array})
|
||||
self.failUnless(array._objects is p._objects)
|
||||
self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array})
|
||||
self.assertTrue(array._objects is p._objects)
|
||||
|
||||
def test_other(self):
|
||||
p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int))
|
||||
self.failUnlessEqual(p[:4], [1,2, 3, 4])
|
||||
self.failUnlessEqual(p[:4:], [1, 2, 3, 4])
|
||||
self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1])
|
||||
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||
self.assertEqual(p[:4], [1,2, 3, 4])
|
||||
self.assertEqual(p[:4:], [1, 2, 3, 4])
|
||||
self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
|
||||
self.assertEqual(p[:4:3], [1, 4])
|
||||
c_int()
|
||||
self.failUnlessEqual(p[:4], [1, 2, 3, 4])
|
||||
self.failUnlessEqual(p[:4:], [1, 2, 3, 4])
|
||||
self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1])
|
||||
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||
self.assertEqual(p[:4], [1, 2, 3, 4])
|
||||
self.assertEqual(p[:4:], [1, 2, 3, 4])
|
||||
self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
|
||||
self.assertEqual(p[:4:3], [1, 4])
|
||||
p[2] = 96
|
||||
self.failUnlessEqual(p[:4], [1, 2, 96, 4])
|
||||
self.failUnlessEqual(p[:4:], [1, 2, 96, 4])
|
||||
self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1])
|
||||
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||
self.assertEqual(p[:4], [1, 2, 96, 4])
|
||||
self.assertEqual(p[:4:], [1, 2, 96, 4])
|
||||
self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
|
||||
self.assertEqual(p[:4:3], [1, 4])
|
||||
c_int()
|
||||
self.failUnlessEqual(p[:4], [1, 2, 96, 4])
|
||||
self.failUnlessEqual(p[:4:], [1, 2, 96, 4])
|
||||
self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1])
|
||||
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||
self.assertEqual(p[:4], [1, 2, 96, 4])
|
||||
self.assertEqual(p[:4:], [1, 2, 96, 4])
|
||||
self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
|
||||
self.assertEqual(p[:4:3], [1, 4])
|
||||
|
||||
def test_char_p(self):
|
||||
# This didn't work: bad argument to internal function
|
||||
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")
|
||||
|
||||
try:
|
||||
|
@ -82,7 +82,7 @@ def test_char_p(self):
|
|||
else:
|
||||
def test_wchar_p(self):
|
||||
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")
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
|
@ -17,176 +17,176 @@ def U(self):
|
|||
def test_byte(self):
|
||||
self._dll.tf_b.restype = c_byte
|
||||
self._dll.tf_b.argtypes = (c_byte,)
|
||||
self.failUnlessEqual(self._dll.tf_b(-126), -42)
|
||||
self.failUnlessEqual(self.S(), -126)
|
||||
self.assertEqual(self._dll.tf_b(-126), -42)
|
||||
self.assertEqual(self.S(), -126)
|
||||
|
||||
def test_byte_plus(self):
|
||||
self._dll.tf_bb.restype = c_byte
|
||||
self._dll.tf_bb.argtypes = (c_byte, c_byte)
|
||||
self.failUnlessEqual(self._dll.tf_bb(0, -126), -42)
|
||||
self.failUnlessEqual(self.S(), -126)
|
||||
self.assertEqual(self._dll.tf_bb(0, -126), -42)
|
||||
self.assertEqual(self.S(), -126)
|
||||
|
||||
def test_ubyte(self):
|
||||
self._dll.tf_B.restype = c_ubyte
|
||||
self._dll.tf_B.argtypes = (c_ubyte,)
|
||||
self.failUnlessEqual(self._dll.tf_B(255), 85)
|
||||
self.failUnlessEqual(self.U(), 255)
|
||||
self.assertEqual(self._dll.tf_B(255), 85)
|
||||
self.assertEqual(self.U(), 255)
|
||||
|
||||
def test_ubyte_plus(self):
|
||||
self._dll.tf_bB.restype = c_ubyte
|
||||
self._dll.tf_bB.argtypes = (c_byte, c_ubyte)
|
||||
self.failUnlessEqual(self._dll.tf_bB(0, 255), 85)
|
||||
self.failUnlessEqual(self.U(), 255)
|
||||
self.assertEqual(self._dll.tf_bB(0, 255), 85)
|
||||
self.assertEqual(self.U(), 255)
|
||||
|
||||
def test_short(self):
|
||||
self._dll.tf_h.restype = c_short
|
||||
self._dll.tf_h.argtypes = (c_short,)
|
||||
self.failUnlessEqual(self._dll.tf_h(-32766), -10922)
|
||||
self.failUnlessEqual(self.S(), -32766)
|
||||
self.assertEqual(self._dll.tf_h(-32766), -10922)
|
||||
self.assertEqual(self.S(), -32766)
|
||||
|
||||
def test_short_plus(self):
|
||||
self._dll.tf_bh.restype = c_short
|
||||
self._dll.tf_bh.argtypes = (c_byte, c_short)
|
||||
self.failUnlessEqual(self._dll.tf_bh(0, -32766), -10922)
|
||||
self.failUnlessEqual(self.S(), -32766)
|
||||
self.assertEqual(self._dll.tf_bh(0, -32766), -10922)
|
||||
self.assertEqual(self.S(), -32766)
|
||||
|
||||
def test_ushort(self):
|
||||
self._dll.tf_H.restype = c_ushort
|
||||
self._dll.tf_H.argtypes = (c_ushort,)
|
||||
self.failUnlessEqual(self._dll.tf_H(65535), 21845)
|
||||
self.failUnlessEqual(self.U(), 65535)
|
||||
self.assertEqual(self._dll.tf_H(65535), 21845)
|
||||
self.assertEqual(self.U(), 65535)
|
||||
|
||||
def test_ushort_plus(self):
|
||||
self._dll.tf_bH.restype = c_ushort
|
||||
self._dll.tf_bH.argtypes = (c_byte, c_ushort)
|
||||
self.failUnlessEqual(self._dll.tf_bH(0, 65535), 21845)
|
||||
self.failUnlessEqual(self.U(), 65535)
|
||||
self.assertEqual(self._dll.tf_bH(0, 65535), 21845)
|
||||
self.assertEqual(self.U(), 65535)
|
||||
|
||||
def test_int(self):
|
||||
self._dll.tf_i.restype = c_int
|
||||
self._dll.tf_i.argtypes = (c_int,)
|
||||
self.failUnlessEqual(self._dll.tf_i(-2147483646), -715827882)
|
||||
self.failUnlessEqual(self.S(), -2147483646)
|
||||
self.assertEqual(self._dll.tf_i(-2147483646), -715827882)
|
||||
self.assertEqual(self.S(), -2147483646)
|
||||
|
||||
def test_int_plus(self):
|
||||
self._dll.tf_bi.restype = c_int
|
||||
self._dll.tf_bi.argtypes = (c_byte, c_int)
|
||||
self.failUnlessEqual(self._dll.tf_bi(0, -2147483646), -715827882)
|
||||
self.failUnlessEqual(self.S(), -2147483646)
|
||||
self.assertEqual(self._dll.tf_bi(0, -2147483646), -715827882)
|
||||
self.assertEqual(self.S(), -2147483646)
|
||||
|
||||
def test_uint(self):
|
||||
self._dll.tf_I.restype = c_uint
|
||||
self._dll.tf_I.argtypes = (c_uint,)
|
||||
self.failUnlessEqual(self._dll.tf_I(4294967295), 1431655765)
|
||||
self.failUnlessEqual(self.U(), 4294967295)
|
||||
self.assertEqual(self._dll.tf_I(4294967295), 1431655765)
|
||||
self.assertEqual(self.U(), 4294967295)
|
||||
|
||||
def test_uint_plus(self):
|
||||
self._dll.tf_bI.restype = c_uint
|
||||
self._dll.tf_bI.argtypes = (c_byte, c_uint)
|
||||
self.failUnlessEqual(self._dll.tf_bI(0, 4294967295), 1431655765)
|
||||
self.failUnlessEqual(self.U(), 4294967295)
|
||||
self.assertEqual(self._dll.tf_bI(0, 4294967295), 1431655765)
|
||||
self.assertEqual(self.U(), 4294967295)
|
||||
|
||||
def test_long(self):
|
||||
self._dll.tf_l.restype = c_long
|
||||
self._dll.tf_l.argtypes = (c_long,)
|
||||
self.failUnlessEqual(self._dll.tf_l(-2147483646), -715827882)
|
||||
self.failUnlessEqual(self.S(), -2147483646)
|
||||
self.assertEqual(self._dll.tf_l(-2147483646), -715827882)
|
||||
self.assertEqual(self.S(), -2147483646)
|
||||
|
||||
def test_long_plus(self):
|
||||
self._dll.tf_bl.restype = c_long
|
||||
self._dll.tf_bl.argtypes = (c_byte, c_long)
|
||||
self.failUnlessEqual(self._dll.tf_bl(0, -2147483646), -715827882)
|
||||
self.failUnlessEqual(self.S(), -2147483646)
|
||||
self.assertEqual(self._dll.tf_bl(0, -2147483646), -715827882)
|
||||
self.assertEqual(self.S(), -2147483646)
|
||||
|
||||
def test_ulong(self):
|
||||
self._dll.tf_L.restype = c_ulong
|
||||
self._dll.tf_L.argtypes = (c_ulong,)
|
||||
self.failUnlessEqual(self._dll.tf_L(4294967295), 1431655765)
|
||||
self.failUnlessEqual(self.U(), 4294967295)
|
||||
self.assertEqual(self._dll.tf_L(4294967295), 1431655765)
|
||||
self.assertEqual(self.U(), 4294967295)
|
||||
|
||||
def test_ulong_plus(self):
|
||||
self._dll.tf_bL.restype = c_ulong
|
||||
self._dll.tf_bL.argtypes = (c_char, c_ulong)
|
||||
self.failUnlessEqual(self._dll.tf_bL(' ', 4294967295), 1431655765)
|
||||
self.failUnlessEqual(self.U(), 4294967295)
|
||||
self.assertEqual(self._dll.tf_bL(' ', 4294967295), 1431655765)
|
||||
self.assertEqual(self.U(), 4294967295)
|
||||
|
||||
def test_longlong(self):
|
||||
self._dll.tf_q.restype = c_longlong
|
||||
self._dll.tf_q.argtypes = (c_longlong, )
|
||||
self.failUnlessEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602)
|
||||
self.failUnlessEqual(self.S(), -9223372036854775806)
|
||||
self.assertEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602)
|
||||
self.assertEqual(self.S(), -9223372036854775806)
|
||||
|
||||
def test_longlong_plus(self):
|
||||
self._dll.tf_bq.restype = c_longlong
|
||||
self._dll.tf_bq.argtypes = (c_byte, c_longlong)
|
||||
self.failUnlessEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602)
|
||||
self.failUnlessEqual(self.S(), -9223372036854775806)
|
||||
self.assertEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602)
|
||||
self.assertEqual(self.S(), -9223372036854775806)
|
||||
|
||||
def test_ulonglong(self):
|
||||
self._dll.tf_Q.restype = c_ulonglong
|
||||
self._dll.tf_Q.argtypes = (c_ulonglong, )
|
||||
self.failUnlessEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205)
|
||||
self.failUnlessEqual(self.U(), 18446744073709551615)
|
||||
self.assertEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205)
|
||||
self.assertEqual(self.U(), 18446744073709551615)
|
||||
|
||||
def test_ulonglong_plus(self):
|
||||
self._dll.tf_bQ.restype = c_ulonglong
|
||||
self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong)
|
||||
self.failUnlessEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205)
|
||||
self.failUnlessEqual(self.U(), 18446744073709551615)
|
||||
self.assertEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205)
|
||||
self.assertEqual(self.U(), 18446744073709551615)
|
||||
|
||||
def test_float(self):
|
||||
self._dll.tf_f.restype = c_float
|
||||
self._dll.tf_f.argtypes = (c_float,)
|
||||
self.failUnlessEqual(self._dll.tf_f(-42.), -14.)
|
||||
self.failUnlessEqual(self.S(), -42)
|
||||
self.assertEqual(self._dll.tf_f(-42.), -14.)
|
||||
self.assertEqual(self.S(), -42)
|
||||
|
||||
def test_float_plus(self):
|
||||
self._dll.tf_bf.restype = c_float
|
||||
self._dll.tf_bf.argtypes = (c_byte, c_float)
|
||||
self.failUnlessEqual(self._dll.tf_bf(0, -42.), -14.)
|
||||
self.failUnlessEqual(self.S(), -42)
|
||||
self.assertEqual(self._dll.tf_bf(0, -42.), -14.)
|
||||
self.assertEqual(self.S(), -42)
|
||||
|
||||
def test_double(self):
|
||||
self._dll.tf_d.restype = c_double
|
||||
self._dll.tf_d.argtypes = (c_double,)
|
||||
self.failUnlessEqual(self._dll.tf_d(42.), 14.)
|
||||
self.failUnlessEqual(self.S(), 42)
|
||||
self.assertEqual(self._dll.tf_d(42.), 14.)
|
||||
self.assertEqual(self.S(), 42)
|
||||
|
||||
def test_double_plus(self):
|
||||
self._dll.tf_bd.restype = c_double
|
||||
self._dll.tf_bd.argtypes = (c_byte, c_double)
|
||||
self.failUnlessEqual(self._dll.tf_bd(0, 42.), 14.)
|
||||
self.failUnlessEqual(self.S(), 42)
|
||||
self.assertEqual(self._dll.tf_bd(0, 42.), 14.)
|
||||
self.assertEqual(self.S(), 42)
|
||||
|
||||
def test_longdouble(self):
|
||||
self._dll.tf_D.restype = c_longdouble
|
||||
self._dll.tf_D.argtypes = (c_longdouble,)
|
||||
self.failUnlessEqual(self._dll.tf_D(42.), 14.)
|
||||
self.failUnlessEqual(self.S(), 42)
|
||||
self.assertEqual(self._dll.tf_D(42.), 14.)
|
||||
self.assertEqual(self.S(), 42)
|
||||
|
||||
def test_longdouble_plus(self):
|
||||
self._dll.tf_bD.restype = c_longdouble
|
||||
self._dll.tf_bD.argtypes = (c_byte, c_longdouble)
|
||||
self.failUnlessEqual(self._dll.tf_bD(0, 42.), 14.)
|
||||
self.failUnlessEqual(self.S(), 42)
|
||||
self.assertEqual(self._dll.tf_bD(0, 42.), 14.)
|
||||
self.assertEqual(self.S(), 42)
|
||||
|
||||
def test_callwithresult(self):
|
||||
def process_result(result):
|
||||
return result * 2
|
||||
self._dll.tf_i.restype = process_result
|
||||
self._dll.tf_i.argtypes = (c_int,)
|
||||
self.failUnlessEqual(self._dll.tf_i(42), 28)
|
||||
self.failUnlessEqual(self.S(), 42)
|
||||
self.failUnlessEqual(self._dll.tf_i(-42), -28)
|
||||
self.failUnlessEqual(self.S(), -42)
|
||||
self.assertEqual(self._dll.tf_i(42), 28)
|
||||
self.assertEqual(self.S(), 42)
|
||||
self.assertEqual(self._dll.tf_i(-42), -28)
|
||||
self.assertEqual(self.S(), -42)
|
||||
|
||||
def test_void(self):
|
||||
self._dll.tv_i.restype = None
|
||||
self._dll.tv_i.argtypes = (c_int,)
|
||||
self.failUnlessEqual(self._dll.tv_i(42), None)
|
||||
self.failUnlessEqual(self.S(), 42)
|
||||
self.failUnlessEqual(self._dll.tv_i(-42), None)
|
||||
self.failUnlessEqual(self.S(), -42)
|
||||
self.assertEqual(self._dll.tv_i(42), None)
|
||||
self.assertEqual(self.S(), 42)
|
||||
self.assertEqual(self._dll.tv_i(-42), None)
|
||||
self.assertEqual(self.S(), -42)
|
||||
|
||||
# The following repeates the above tests with stdcall functions (where
|
||||
# they are available)
|
||||
|
|
|
@ -14,16 +14,16 @@ def test_checkretval(self):
|
|||
|
||||
import _ctypes_test
|
||||
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
|
||||
self.failUnlessEqual("42", dll._testfunc_p_p(42))
|
||||
self.assertEqual("42", dll._testfunc_p_p(42))
|
||||
|
||||
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
|
||||
self.failUnlessEqual(42, dll._testfunc_p_p(42))
|
||||
self.assertEqual(42, dll._testfunc_p_p(42))
|
||||
|
||||
try:
|
||||
oledll
|
||||
|
@ -31,7 +31,7 @@ def test_checkretval(self):
|
|||
pass
|
||||
else:
|
||||
def test_oledll(self):
|
||||
self.failUnlessRaises(WindowsError,
|
||||
self.assertRaises(WindowsError,
|
||||
oledll.oleaut32.CreateTypeLib2,
|
||||
0, None, None)
|
||||
|
||||
|
|
|
@ -15,11 +15,11 @@ def test_open(self):
|
|||
|
||||
libc_open.argtypes = c_char_p, c_int
|
||||
|
||||
self.failUnlessEqual(libc_open("", 0), -1)
|
||||
self.failUnlessEqual(get_errno(), errno.ENOENT)
|
||||
self.assertEqual(libc_open("", 0), -1)
|
||||
self.assertEqual(get_errno(), errno.ENOENT)
|
||||
|
||||
self.failUnlessEqual(set_errno(32), errno.ENOENT)
|
||||
self.failUnlessEqual(get_errno(), 32)
|
||||
self.assertEqual(set_errno(32), errno.ENOENT)
|
||||
self.assertEqual(get_errno(), 32)
|
||||
|
||||
|
||||
def _worker():
|
||||
|
@ -31,14 +31,14 @@ def _worker():
|
|||
else:
|
||||
libc_open = libc.open
|
||||
libc_open.argtypes = c_char_p, c_int
|
||||
self.failUnlessEqual(libc_open("", 0), -1)
|
||||
self.failUnlessEqual(get_errno(), 0)
|
||||
self.assertEqual(libc_open("", 0), -1)
|
||||
self.assertEqual(get_errno(), 0)
|
||||
|
||||
t = threading.Thread(target=_worker)
|
||||
t.start()
|
||||
t.join()
|
||||
|
||||
self.failUnlessEqual(get_errno(), 32)
|
||||
self.assertEqual(get_errno(), 32)
|
||||
set_errno(0)
|
||||
|
||||
if os.name == "nt":
|
||||
|
@ -48,11 +48,11 @@ def test_GetLastError(self):
|
|||
GetModuleHandle = dll.GetModuleHandleA
|
||||
GetModuleHandle.argtypes = [c_wchar_p]
|
||||
|
||||
self.failUnlessEqual(0, GetModuleHandle("foo"))
|
||||
self.failUnlessEqual(get_last_error(), 126)
|
||||
self.assertEqual(0, GetModuleHandle("foo"))
|
||||
self.assertEqual(get_last_error(), 126)
|
||||
|
||||
self.failUnlessEqual(set_last_error(32), 126)
|
||||
self.failUnlessEqual(get_last_error(), 32)
|
||||
self.assertEqual(set_last_error(32), 126)
|
||||
self.assertEqual(get_last_error(), 32)
|
||||
|
||||
def _worker():
|
||||
set_last_error(0)
|
||||
|
@ -62,13 +62,13 @@ def _worker():
|
|||
GetModuleHandle.argtypes = [c_wchar_p]
|
||||
GetModuleHandle("bar")
|
||||
|
||||
self.failUnlessEqual(get_last_error(), 0)
|
||||
self.assertEqual(get_last_error(), 0)
|
||||
|
||||
t = threading.Thread(target=_worker)
|
||||
t.start()
|
||||
t.join()
|
||||
|
||||
self.failUnlessEqual(get_last_error(), 32)
|
||||
self.assertEqual(get_last_error(), 32)
|
||||
|
||||
set_last_error(0)
|
||||
|
||||
|
|
|
@ -76,7 +76,7 @@ def test_gle(self):
|
|||
## sqrt = libm.sqrt
|
||||
## sqrt.argtypes = (c_double,)
|
||||
## sqrt.restype = c_double
|
||||
## self.failUnlessEqual(sqrt(2), math.sqrt(2))
|
||||
## self.assertEqual(sqrt(2), math.sqrt(2))
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -16,14 +16,14 @@ def test_fom_buffer(self):
|
|||
|
||||
y = X.from_buffer(a)
|
||||
self.assertEqual(y.c_int, a[0])
|
||||
self.failIf(y.init_called)
|
||||
self.assertFalse(y.init_called)
|
||||
|
||||
self.assertEqual(x[:], a.tolist())
|
||||
|
||||
a[0], a[-1] = 200, -200
|
||||
self.assertEqual(x[:], a.tolist())
|
||||
|
||||
self.assert_(a in x._objects.values())
|
||||
self.assertTrue(a in x._objects.values())
|
||||
|
||||
self.assertRaises(ValueError,
|
||||
c_int.from_buffer, a, -1)
|
||||
|
@ -49,7 +49,7 @@ def test_from_buffer_copy(self):
|
|||
|
||||
y = X.from_buffer_copy(a)
|
||||
self.assertEqual(y.c_int, a[0])
|
||||
self.failIf(y.init_called)
|
||||
self.assertFalse(y.init_called)
|
||||
|
||||
self.assertEqual(x[:], list(range(16)))
|
||||
|
||||
|
|
|
@ -18,10 +18,10 @@ def func(*args):
|
|||
return len(args)
|
||||
|
||||
x = X(func)
|
||||
self.failUnlessEqual(x.restype, c_int)
|
||||
self.failUnlessEqual(x.argtypes, (c_int, c_int))
|
||||
self.failUnlessEqual(sizeof(x), sizeof(c_voidp))
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_voidp))
|
||||
self.assertEqual(x.restype, c_int)
|
||||
self.assertEqual(x.argtypes, (c_int, c_int))
|
||||
self.assertEqual(sizeof(x), sizeof(c_voidp))
|
||||
self.assertEqual(sizeof(X), sizeof(c_voidp))
|
||||
|
||||
def test_first(self):
|
||||
StdCallback = WINFUNCTYPE(c_int, c_int, c_int)
|
||||
|
@ -33,12 +33,12 @@ def func(a, b):
|
|||
s = StdCallback(func)
|
||||
c = CdeclCallback(func)
|
||||
|
||||
self.failUnlessEqual(s(1, 2), 3)
|
||||
self.failUnlessEqual(c(1, 2), 3)
|
||||
self.assertEqual(s(1, 2), 3)
|
||||
self.assertEqual(c(1, 2), 3)
|
||||
# The following no longer raises a TypeError - it is now
|
||||
# possible, as in C, to call cdecl functions with more parameters.
|
||||
#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":
|
||||
self.assertRaises(TypeError, s, 1, 2, 3)
|
||||
|
||||
|
@ -75,9 +75,9 @@ class WNDCLASS(Structure):
|
|||
## "lpfnWndProc", WNDPROC_2(wndproc))
|
||||
# instead:
|
||||
|
||||
self.failUnless(WNDPROC is WNDPROC_2)
|
||||
self.assertTrue(WNDPROC is WNDPROC_2)
|
||||
# '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
|
||||
|
@ -85,7 +85,7 @@ class WNDCLASS(Structure):
|
|||
del wndclass
|
||||
del wndproc
|
||||
|
||||
self.failUnlessEqual(f(10, 11, 12, 13), 46)
|
||||
self.assertEqual(f(10, 11, 12, 13), 46)
|
||||
|
||||
def test_dllfunctions(self):
|
||||
|
||||
|
@ -97,8 +97,8 @@ def NoNullHandle(value):
|
|||
strchr = lib.my_strchr
|
||||
strchr.restype = c_char_p
|
||||
strchr.argtypes = (c_char_p, c_char)
|
||||
self.failUnlessEqual(strchr("abcdefghi", "b"), "bcdefghi")
|
||||
self.failUnlessEqual(strchr("abcdefghi", "x"), None)
|
||||
self.assertEqual(strchr("abcdefghi", "b"), "bcdefghi")
|
||||
self.assertEqual(strchr("abcdefghi", "x"), None)
|
||||
|
||||
|
||||
strtok = lib.my_strtok
|
||||
|
@ -118,10 +118,10 @@ def c_string(init):
|
|||
## b.value = s
|
||||
|
||||
## b = c_string(s)
|
||||
self.failUnlessEqual(strtok(b, b"\n"), "a")
|
||||
self.failUnlessEqual(strtok(None, b"\n"), "b")
|
||||
self.failUnlessEqual(strtok(None, b"\n"), "c")
|
||||
self.failUnlessEqual(strtok(None, b"\n"), None)
|
||||
self.assertEqual(strtok(b, b"\n"), "a")
|
||||
self.assertEqual(strtok(None, b"\n"), "b")
|
||||
self.assertEqual(strtok(None, b"\n"), "c")
|
||||
self.assertEqual(strtok(None, b"\n"), None)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
|
@ -71,8 +71,8 @@ def test_wchar_parm(self):
|
|||
f = dll._testfunc_i_bhilfd
|
||||
f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
|
||||
result = f(1, "x", 3, 4, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 139)
|
||||
self.failUnlessEqual(type(result), int)
|
||||
self.assertEqual(result, 139)
|
||||
self.assertEqual(type(result), int)
|
||||
|
||||
def test_wchar_result(self):
|
||||
try:
|
||||
|
@ -83,38 +83,38 @@ def test_wchar_result(self):
|
|||
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
|
||||
f.restype = c_wchar
|
||||
result = f(0, 0, 0, 0, 0, 0)
|
||||
self.failUnlessEqual(result, '\x00')
|
||||
self.assertEqual(result, '\x00')
|
||||
|
||||
def test_voidresult(self):
|
||||
f = dll._testfunc_v
|
||||
f.restype = None
|
||||
f.argtypes = [c_int, c_int, POINTER(c_int)]
|
||||
result = c_int()
|
||||
self.failUnlessEqual(None, f(1, 2, byref(result)))
|
||||
self.failUnlessEqual(result.value, 3)
|
||||
self.assertEqual(None, f(1, 2, byref(result)))
|
||||
self.assertEqual(result.value, 3)
|
||||
|
||||
def test_intresult(self):
|
||||
f = dll._testfunc_i_bhilfd
|
||||
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
|
||||
f.restype = c_int
|
||||
result = f(1, 2, 3, 4, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 21)
|
||||
self.failUnlessEqual(type(result), int)
|
||||
self.assertEqual(result, 21)
|
||||
self.assertEqual(type(result), int)
|
||||
|
||||
result = f(-1, -2, -3, -4, -5.0, -6.0)
|
||||
self.failUnlessEqual(result, -21)
|
||||
self.failUnlessEqual(type(result), int)
|
||||
self.assertEqual(result, -21)
|
||||
self.assertEqual(type(result), int)
|
||||
|
||||
# If we declare the function to return a short,
|
||||
# is the high part split off?
|
||||
f.restype = c_short
|
||||
result = f(1, 2, 3, 4, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 21)
|
||||
self.failUnlessEqual(type(result), int)
|
||||
self.assertEqual(result, 21)
|
||||
self.assertEqual(type(result), int)
|
||||
|
||||
result = f(1, 2, 3, 0x10004, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 21)
|
||||
self.failUnlessEqual(type(result), int)
|
||||
self.assertEqual(result, 21)
|
||||
self.assertEqual(type(result), int)
|
||||
|
||||
# You cannot assing character format codes as restype any longer
|
||||
self.assertRaises(TypeError, setattr, f, "restype", "i")
|
||||
|
@ -124,36 +124,36 @@ def test_floatresult(self):
|
|||
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
|
||||
f.restype = c_float
|
||||
result = f(1, 2, 3, 4, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 21)
|
||||
self.failUnlessEqual(type(result), float)
|
||||
self.assertEqual(result, 21)
|
||||
self.assertEqual(type(result), float)
|
||||
|
||||
result = f(-1, -2, -3, -4, -5.0, -6.0)
|
||||
self.failUnlessEqual(result, -21)
|
||||
self.failUnlessEqual(type(result), float)
|
||||
self.assertEqual(result, -21)
|
||||
self.assertEqual(type(result), float)
|
||||
|
||||
def test_doubleresult(self):
|
||||
f = dll._testfunc_d_bhilfd
|
||||
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
|
||||
f.restype = c_double
|
||||
result = f(1, 2, 3, 4, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 21)
|
||||
self.failUnlessEqual(type(result), float)
|
||||
self.assertEqual(result, 21)
|
||||
self.assertEqual(type(result), float)
|
||||
|
||||
result = f(-1, -2, -3, -4, -5.0, -6.0)
|
||||
self.failUnlessEqual(result, -21)
|
||||
self.failUnlessEqual(type(result), float)
|
||||
self.assertEqual(result, -21)
|
||||
self.assertEqual(type(result), float)
|
||||
|
||||
def test_longdoubleresult(self):
|
||||
f = dll._testfunc_D_bhilfD
|
||||
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble]
|
||||
f.restype = c_longdouble
|
||||
result = f(1, 2, 3, 4, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 21)
|
||||
self.failUnlessEqual(type(result), float)
|
||||
self.assertEqual(result, 21)
|
||||
self.assertEqual(type(result), float)
|
||||
|
||||
result = f(-1, -2, -3, -4, -5.0, -6.0)
|
||||
self.failUnlessEqual(result, -21)
|
||||
self.failUnlessEqual(type(result), float)
|
||||
self.assertEqual(result, -21)
|
||||
self.assertEqual(type(result), float)
|
||||
|
||||
def test_longlongresult(self):
|
||||
try:
|
||||
|
@ -164,23 +164,23 @@ def test_longlongresult(self):
|
|||
f.restype = c_longlong
|
||||
f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
|
||||
result = f(1, 2, 3, 4, 5.0, 6.0)
|
||||
self.failUnlessEqual(result, 21)
|
||||
self.assertEqual(result, 21)
|
||||
|
||||
f = dll._testfunc_q_bhilfdq
|
||||
f.restype = 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)
|
||||
self.failUnlessEqual(result, 42)
|
||||
self.assertEqual(result, 42)
|
||||
|
||||
def test_stringresult(self):
|
||||
f = dll._testfunc_p_p
|
||||
f.argtypes = None
|
||||
f.restype = c_char_p
|
||||
result = f(b"123")
|
||||
self.failUnlessEqual(result, "123")
|
||||
self.assertEqual(result, "123")
|
||||
|
||||
result = f(None)
|
||||
self.failUnlessEqual(result, None)
|
||||
self.assertEqual(result, None)
|
||||
|
||||
def test_pointers(self):
|
||||
f = dll._testfunc_p_p
|
||||
|
@ -193,29 +193,29 @@ def test_pointers(self):
|
|||
|
||||
v = c_int(42)
|
||||
|
||||
self.failUnlessEqual(pointer(v).contents.value, 42)
|
||||
self.assertEqual(pointer(v).contents.value, 42)
|
||||
result = f(pointer(v))
|
||||
self.failUnlessEqual(type(result), POINTER(c_int))
|
||||
self.failUnlessEqual(result.contents.value, 42)
|
||||
self.assertEqual(type(result), POINTER(c_int))
|
||||
self.assertEqual(result.contents.value, 42)
|
||||
|
||||
# This on works...
|
||||
result = f(pointer(v))
|
||||
self.failUnlessEqual(result.contents.value, v.value)
|
||||
self.assertEqual(result.contents.value, v.value)
|
||||
|
||||
p = pointer(c_int(99))
|
||||
result = f(p)
|
||||
self.failUnlessEqual(result.contents.value, 99)
|
||||
self.assertEqual(result.contents.value, 99)
|
||||
|
||||
arg = byref(v)
|
||||
result = f(arg)
|
||||
self.failIfEqual(result.contents, v.value)
|
||||
self.assertNotEqual(result.contents, v.value)
|
||||
|
||||
self.assertRaises(ArgumentError, f, byref(c_short(22)))
|
||||
|
||||
# It is dangerous, however, because you don't control the lifetime
|
||||
# of the pointer:
|
||||
result = f(byref(c_int(99)))
|
||||
self.failIfEqual(result.contents, 99)
|
||||
self.assertNotEqual(result.contents, 99)
|
||||
|
||||
def test_errors(self):
|
||||
f = dll._testfunc_p_p
|
||||
|
@ -242,7 +242,7 @@ def callback(v):
|
|||
|
||||
cb = CallBack(callback)
|
||||
f(2**18, cb)
|
||||
self.failUnlessEqual(args, expected)
|
||||
self.assertEqual(args, expected)
|
||||
|
||||
################################################################
|
||||
|
||||
|
@ -259,13 +259,13 @@ def callback(value):
|
|||
|
||||
cb = MyCallback(callback)
|
||||
result = f(-10, cb)
|
||||
self.failUnlessEqual(result, -18)
|
||||
self.assertEqual(result, -18)
|
||||
|
||||
# test with prototype
|
||||
f.argtypes = [c_int, MyCallback]
|
||||
cb = MyCallback(callback)
|
||||
result = f(-10, cb)
|
||||
self.failUnlessEqual(result, -18)
|
||||
self.assertEqual(result, -18)
|
||||
|
||||
AnotherCallback = WINFUNCTYPE(c_int, c_int, c_int, c_int, c_int)
|
||||
|
||||
|
@ -288,12 +288,12 @@ def test_callbacks_2(self):
|
|||
|
||||
def callback(value):
|
||||
#print "called back with", value
|
||||
self.failUnlessEqual(type(value), int)
|
||||
self.assertEqual(type(value), int)
|
||||
return value
|
||||
|
||||
cb = MyCallback(callback)
|
||||
result = f(-10, cb)
|
||||
self.failUnlessEqual(result, -18)
|
||||
self.assertEqual(result, -18)
|
||||
|
||||
def test_longlong_callbacks(self):
|
||||
|
||||
|
@ -305,12 +305,12 @@ def test_longlong_callbacks(self):
|
|||
f.argtypes = [c_longlong, MyCallback]
|
||||
|
||||
def callback(value):
|
||||
self.failUnless(isinstance(value, int))
|
||||
self.assertTrue(isinstance(value, int))
|
||||
return value & 0x7FFFFFFF
|
||||
|
||||
cb = MyCallback(callback)
|
||||
|
||||
self.failUnlessEqual(13577625587, f(1000000000000, cb))
|
||||
self.assertEqual(13577625587, f(1000000000000, cb))
|
||||
|
||||
def test_errors(self):
|
||||
self.assertRaises(AttributeError, getattr, dll, "_xxx_yyy")
|
||||
|
@ -325,7 +325,7 @@ def test_byval(self):
|
|||
result = dll._testfunc_byval(ptin, byref(ptout))
|
||||
got = result, ptout.x, ptout.y
|
||||
expected = 3, 1, 2
|
||||
self.failUnlessEqual(got, expected)
|
||||
self.assertEqual(got, expected)
|
||||
|
||||
# with prototype
|
||||
ptin = POINT(101, 102)
|
||||
|
@ -335,7 +335,7 @@ def test_byval(self):
|
|||
result = dll._testfunc_byval(ptin, byref(ptout))
|
||||
got = result, ptout.x, ptout.y
|
||||
expected = 203, 101, 102
|
||||
self.failUnlessEqual(got, expected)
|
||||
self.assertEqual(got, expected)
|
||||
|
||||
def test_struct_return_2H(self):
|
||||
class S2H(Structure):
|
||||
|
@ -345,7 +345,7 @@ class S2H(Structure):
|
|||
dll.ret_2h_func.argtypes = [S2H]
|
||||
inp = S2H(99, 88)
|
||||
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":
|
||||
def test_struct_return_2H_stdcall(self):
|
||||
|
@ -356,7 +356,7 @@ class S2H(Structure):
|
|||
windll.s_ret_2h_func.restype = S2H
|
||||
windll.s_ret_2h_func.argtypes = [S2H]
|
||||
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):
|
||||
class S8I(Structure):
|
||||
|
@ -372,7 +372,7 @@ class S8I(Structure):
|
|||
dll.ret_8i_func.argtypes = [S8I]
|
||||
inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
|
||||
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))
|
||||
|
||||
if sys.platform == "win32":
|
||||
|
@ -390,7 +390,7 @@ class S8I(Structure):
|
|||
windll.s_ret_8i_func.argtypes = [S8I]
|
||||
inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
|
||||
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))
|
||||
|
||||
def test_sf1651235(self):
|
||||
|
@ -401,7 +401,7 @@ def callback(*args):
|
|||
return 0
|
||||
|
||||
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__':
|
||||
unittest.main()
|
||||
|
|
|
@ -30,7 +30,7 @@ class cell(Structure):
|
|||
for i in range(8):
|
||||
result.append(p.name)
|
||||
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
|
||||
from ctypes import _pointer_type_cache
|
||||
|
|
|
@ -24,17 +24,17 @@ def test_get(self):
|
|||
# make sure the only accessing a nested structure
|
||||
# doesn't call the structure's __new__ and __init__
|
||||
y = Y()
|
||||
self.failUnlessEqual((y.x.a, y.x.b), (0, 0))
|
||||
self.failUnlessEqual(y.x.new_was_called, False)
|
||||
self.assertEqual((y.x.a, y.x.b), (0, 0))
|
||||
self.assertEqual(y.x.new_was_called, False)
|
||||
|
||||
# But explicitely creating an X structure calls __new__ and __init__, of course.
|
||||
x = X()
|
||||
self.failUnlessEqual((x.a, x.b), (9, 12))
|
||||
self.failUnlessEqual(x.new_was_called, True)
|
||||
self.assertEqual((x.a, x.b), (9, 12))
|
||||
self.assertEqual(x.new_was_called, True)
|
||||
|
||||
y.x = x
|
||||
self.failUnlessEqual((y.x.a, y.x.b), (9, 12))
|
||||
self.failUnlessEqual(y.x.new_was_called, False)
|
||||
self.assertEqual((y.x.a, y.x.b), (9, 12))
|
||||
self.assertEqual(y.x.new_was_called, False)
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -18,22 +18,22 @@
|
|||
"""
|
||||
|
||||
class ObjectsTestCase(unittest.TestCase):
|
||||
def failUnlessSame(self, a, b):
|
||||
self.failUnlessEqual(id(a), id(b))
|
||||
def assertTrueSame(self, a, b):
|
||||
self.assertEqual(id(a), id(b))
|
||||
|
||||
def test_ints(self):
|
||||
i = 42000123
|
||||
rc = grc(i)
|
||||
ci = c_int(i)
|
||||
self.failUnlessEqual(rc, grc(i))
|
||||
self.failUnlessEqual(ci._objects, None)
|
||||
self.assertEqual(rc, grc(i))
|
||||
self.assertEqual(ci._objects, None)
|
||||
|
||||
def test_c_char_p(self):
|
||||
s = b"Hello, World"
|
||||
rc = grc(s)
|
||||
cs = c_char_p(s)
|
||||
self.failUnlessEqual(rc + 1, grc(s))
|
||||
self.failUnlessSame(cs._objects, s)
|
||||
self.assertEqual(rc + 1, grc(s))
|
||||
self.assertTrueSame(cs._objects, s)
|
||||
|
||||
def test_simple_struct(self):
|
||||
class X(Structure):
|
||||
|
@ -42,10 +42,10 @@ class X(Structure):
|
|||
a = 421234
|
||||
b = 421235
|
||||
x = X()
|
||||
self.failUnlessEqual(x._objects, None)
|
||||
self.assertEqual(x._objects, None)
|
||||
x.a = a
|
||||
x.b = b
|
||||
self.failUnlessEqual(x._objects, None)
|
||||
self.assertEqual(x._objects, None)
|
||||
|
||||
def test_embedded_structs(self):
|
||||
class X(Structure):
|
||||
|
@ -55,13 +55,13 @@ class Y(Structure):
|
|||
_fields_ = [("x", X), ("y", X)]
|
||||
|
||||
y = Y()
|
||||
self.failUnlessEqual(y._objects, None)
|
||||
self.assertEqual(y._objects, None)
|
||||
|
||||
x1, x2 = X(), X()
|
||||
y.x, y.y = x1, x2
|
||||
self.failUnlessEqual(y._objects, {"0": {}, "1": {}})
|
||||
self.assertEqual(y._objects, {"0": {}, "1": {}})
|
||||
x1.a, x2.b = 42, 93
|
||||
self.failUnlessEqual(y._objects, {"0": {}, "1": {}})
|
||||
self.assertEqual(y._objects, {"0": {}, "1": {}})
|
||||
|
||||
def test_xxx(self):
|
||||
class X(Structure):
|
||||
|
@ -76,12 +76,12 @@ class Y(Structure):
|
|||
x = X()
|
||||
x.a = s1
|
||||
x.b = s2
|
||||
self.failUnlessEqual(x._objects, {"0": bytes(s1, "ascii"),
|
||||
self.assertEqual(x._objects, {"0": bytes(s1, "ascii"),
|
||||
"1": bytes(s2, "ascii")})
|
||||
|
||||
y = Y()
|
||||
y.x = x
|
||||
self.failUnlessEqual(y._objects, {"0": {"0": bytes(s1, "ascii"),
|
||||
self.assertEqual(y._objects, {"0": {"0": bytes(s1, "ascii"),
|
||||
"1": bytes(s2, "ascii")}})
|
||||
## x = y.x
|
||||
## del y
|
||||
|
@ -93,7 +93,7 @@ class X(Structure):
|
|||
|
||||
A = c_int*4
|
||||
a = A(11, 22, 33, 44)
|
||||
self.failUnlessEqual(a._objects, None)
|
||||
self.assertEqual(a._objects, None)
|
||||
|
||||
x = X()
|
||||
x.data = a
|
||||
|
|
|
@ -91,7 +91,7 @@ class PointerTestCase(unittest.TestCase):
|
|||
def test_p_cint(self):
|
||||
i = c_int(42)
|
||||
x = pointer(i)
|
||||
self.failUnlessEqual(x._objects, {'1': i})
|
||||
self.assertEqual(x._objects, {'1': i})
|
||||
|
||||
class DeletePointerTestCase(unittest.TestCase):
|
||||
def X_test(self):
|
||||
|
|
|
@ -13,9 +13,9 @@ class LibTest(unittest.TestCase):
|
|||
def test_sqrt(self):
|
||||
lib.my_sqrt.argtypes = 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
|
||||
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):
|
||||
comparefunc = CFUNCTYPE(c_int, POINTER(c_char), POINTER(c_char))
|
||||
|
@ -27,7 +27,7 @@ def sort(a, b):
|
|||
|
||||
chars = create_string_buffer("spam, spam, and spam")
|
||||
lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort))
|
||||
self.failUnlessEqual(chars.raw, b" ,,aaaadmmmnpppsss\x00")
|
||||
self.assertEqual(chars.raw, b" ,,aaaadmmmnpppsss\x00")
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -43,7 +43,7 @@ def test_find(self):
|
|||
|
||||
if os.name in ("nt", "ce"):
|
||||
def test_load_library(self):
|
||||
self.failIf(libc_name is None)
|
||||
self.assertFalse(libc_name is None)
|
||||
if is_resource_enabled("printing"):
|
||||
print(find_library("kernel32"))
|
||||
print(find_library("user32"))
|
||||
|
@ -70,9 +70,9 @@ def test_load_ordinal_functions(self):
|
|||
a_name = addressof(func_name)
|
||||
f_ord_addr = c_void_p.from_address(a_ord).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":
|
||||
def test_1703286_A(self):
|
||||
|
@ -94,13 +94,13 @@ def test_1703286_B(self):
|
|||
advapi32 = windll.advapi32
|
||||
# Calling CloseEventLog with a NULL argument should fail,
|
||||
# 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.restype = c_void_p
|
||||
proc = windll.kernel32.GetProcAddress(advapi32._handle, "CloseEventLog")
|
||||
self.failUnless(proc)
|
||||
self.assertTrue(proc)
|
||||
# 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__":
|
||||
unittest.main()
|
||||
|
|
|
@ -48,14 +48,14 @@ class MachOTest(unittest.TestCase):
|
|||
if sys.platform == "darwin":
|
||||
def test_find(self):
|
||||
|
||||
self.failUnlessEqual(find_lib('pthread'),
|
||||
self.assertEqual(find_lib('pthread'),
|
||||
'/usr/lib/libSystem.B.dylib')
|
||||
|
||||
result = find_lib('z')
|
||||
self.failUnless(result.startswith('/usr/lib/libz.1'))
|
||||
self.failUnless(result.endswith('.dylib'))
|
||||
self.assertTrue(result.startswith('/usr/lib/libz.1'))
|
||||
self.assertTrue(result.endswith('.dylib'))
|
||||
|
||||
self.failUnlessEqual(find_lib('IOKit'),
|
||||
self.assertEqual(find_lib('IOKit'),
|
||||
'/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit')
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
|
@ -19,45 +19,45 @@ def test_memmove(self):
|
|||
a = create_string_buffer(1000000)
|
||||
p = b"Hello, World"
|
||||
result = memmove(a, p, len(p))
|
||||
self.failUnlessEqual(a.value, b"Hello, World")
|
||||
self.assertEqual(a.value, b"Hello, World")
|
||||
|
||||
self.failUnlessEqual(string_at(result), b"Hello, World")
|
||||
self.failUnlessEqual(string_at(result, 5), b"Hello")
|
||||
self.failUnlessEqual(string_at(result, 16), b"Hello, World\0\0\0\0")
|
||||
self.failUnlessEqual(string_at(result, 0), b"")
|
||||
self.assertEqual(string_at(result), b"Hello, World")
|
||||
self.assertEqual(string_at(result, 5), b"Hello")
|
||||
self.assertEqual(string_at(result, 16), b"Hello, World\0\0\0\0")
|
||||
self.assertEqual(string_at(result, 0), b"")
|
||||
|
||||
def test_memset(self):
|
||||
a = create_string_buffer(1000000)
|
||||
result = memset(a, ord('x'), 16)
|
||||
self.failUnlessEqual(a.value, b"xxxxxxxxxxxxxxxx")
|
||||
self.assertEqual(a.value, b"xxxxxxxxxxxxxxxx")
|
||||
|
||||
self.failUnlessEqual(string_at(result), b"xxxxxxxxxxxxxxxx")
|
||||
self.failUnlessEqual(string_at(a), b"xxxxxxxxxxxxxxxx")
|
||||
self.failUnlessEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0")
|
||||
self.assertEqual(string_at(result), b"xxxxxxxxxxxxxxxx")
|
||||
self.assertEqual(string_at(a), b"xxxxxxxxxxxxxxxx")
|
||||
self.assertEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0")
|
||||
|
||||
def test_cast(self):
|
||||
a = (c_ubyte * 32)(*map(ord, "abcdef"))
|
||||
self.failUnlessEqual(cast(a, c_char_p).value, "abcdef")
|
||||
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7],
|
||||
self.assertEqual(cast(a, c_char_p).value, "abcdef")
|
||||
self.assertEqual(cast(a, POINTER(c_byte))[:7],
|
||||
[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])
|
||||
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])
|
||||
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:2],
|
||||
self.assertEqual(cast(a, POINTER(c_byte))[:7:2],
|
||||
[97, 99, 101, 0])
|
||||
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:7],
|
||||
self.assertEqual(cast(a, POINTER(c_byte))[:7:7],
|
||||
[97])
|
||||
|
||||
def test_string_at(self):
|
||||
s = string_at(b"foo bar")
|
||||
# XXX The following may be wrong, depending on how Python
|
||||
# manages string instances
|
||||
self.failUnlessEqual(2, sys.getrefcount(s))
|
||||
self.failUnless(s, "foo bar")
|
||||
self.assertEqual(2, sys.getrefcount(s))
|
||||
self.assertTrue(s, "foo bar")
|
||||
|
||||
self.failUnlessEqual(string_at(b"foo bar", 7), b"foo bar")
|
||||
self.failUnlessEqual(string_at(b"foo bar", 3), b"foo")
|
||||
self.assertEqual(string_at(b"foo bar", 7), b"foo bar")
|
||||
self.assertEqual(string_at(b"foo bar", 3), b"foo")
|
||||
|
||||
try:
|
||||
create_unicode_buffer
|
||||
|
@ -68,12 +68,12 @@ def test_wstring_at(self):
|
|||
p = create_unicode_buffer("Hello, World")
|
||||
a = create_unicode_buffer(1000000)
|
||||
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.failUnlessEqual(wstring_at(a, 5), "Hello")
|
||||
self.failUnlessEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
|
||||
self.failUnlessEqual(wstring_at(a, 0), "")
|
||||
self.assertEqual(wstring_at(a), "Hello, World")
|
||||
self.assertEqual(wstring_at(a, 5), "Hello")
|
||||
self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
|
||||
self.assertEqual(wstring_at(a, 0), "")
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -55,25 +55,25 @@ class NumberTestCase(unittest.TestCase):
|
|||
def test_default_init(self):
|
||||
# default values are set to zero
|
||||
for t in signed_types + unsigned_types + float_types:
|
||||
self.failUnlessEqual(t().value, 0)
|
||||
self.assertEqual(t().value, 0)
|
||||
|
||||
def test_unsigned_values(self):
|
||||
# the value given to the constructor is available
|
||||
# as the 'value' attribute
|
||||
for t, (l, h) in zip(unsigned_types, unsigned_ranges):
|
||||
self.failUnlessEqual(t(l).value, l)
|
||||
self.failUnlessEqual(t(h).value, h)
|
||||
self.assertEqual(t(l).value, l)
|
||||
self.assertEqual(t(h).value, h)
|
||||
|
||||
def test_signed_values(self):
|
||||
# see above
|
||||
for t, (l, h) in zip(signed_types, signed_ranges):
|
||||
self.failUnlessEqual(t(l).value, l)
|
||||
self.failUnlessEqual(t(h).value, h)
|
||||
self.assertEqual(t(l).value, l)
|
||||
self.assertEqual(t(h).value, h)
|
||||
|
||||
def test_bool_values(self):
|
||||
from operator import truth
|
||||
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):
|
||||
# Only numbers are allowed in the contructor,
|
||||
|
@ -93,13 +93,13 @@ def test_from_param(self):
|
|||
# the from_param class method attribute always
|
||||
# returns PyCArgObject instances
|
||||
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):
|
||||
# calling byref returns also a PyCArgObject instance
|
||||
for t in signed_types + unsigned_types + float_types + bool_types:
|
||||
parm = byref(t())
|
||||
self.failUnlessEqual(ArgType, type(parm))
|
||||
self.assertEqual(ArgType, type(parm))
|
||||
|
||||
|
||||
def test_floats(self):
|
||||
|
@ -110,10 +110,10 @@ def __float__(self):
|
|||
return 2.0
|
||||
f = FloatLike()
|
||||
for t in float_types:
|
||||
self.failUnlessEqual(t(2.0).value, 2.0)
|
||||
self.failUnlessEqual(t(2).value, 2.0)
|
||||
self.failUnlessEqual(t(2).value, 2.0)
|
||||
self.failUnlessEqual(t(f).value, 2.0)
|
||||
self.assertEqual(t(2.0).value, 2.0)
|
||||
self.assertEqual(t(2).value, 2.0)
|
||||
self.assertEqual(t(2).value, 2.0)
|
||||
self.assertEqual(t(f).value, 2.0)
|
||||
|
||||
def test_integers(self):
|
||||
class FloatLike(object):
|
||||
|
@ -129,7 +129,7 @@ def __int__(self):
|
|||
for t in signed_types + unsigned_types:
|
||||
self.assertRaises(TypeError, t, 3.14)
|
||||
self.assertRaises(TypeError, t, f)
|
||||
self.failUnlessEqual(t(i).value, 2)
|
||||
self.assertEqual(t(i).value, 2)
|
||||
|
||||
def test_sizes(self):
|
||||
for t in signed_types + unsigned_types + float_types + bool_types:
|
||||
|
@ -138,9 +138,9 @@ def test_sizes(self):
|
|||
except struct.error:
|
||||
continue
|
||||
# sizeof of the type...
|
||||
self.failUnlessEqual(sizeof(t), size)
|
||||
self.assertEqual(sizeof(t), size)
|
||||
# and sizeof of an instance
|
||||
self.failUnlessEqual(sizeof(t()), size)
|
||||
self.assertEqual(sizeof(t()), size)
|
||||
|
||||
def test_alignments(self):
|
||||
for t in signed_types + unsigned_types + float_types:
|
||||
|
@ -148,10 +148,10 @@ def test_alignments(self):
|
|||
align = struct.calcsize("c%c" % code) - struct.calcsize(code)
|
||||
|
||||
# alignment of the type...
|
||||
self.failUnlessEqual((code, alignment(t)),
|
||||
self.assertEqual((code, alignment(t)),
|
||||
(code, align))
|
||||
# and alignment of an instance
|
||||
self.failUnlessEqual((code, alignment(t())),
|
||||
self.assertEqual((code, alignment(t())),
|
||||
(code, align))
|
||||
|
||||
def test_int_from_address(self):
|
||||
|
@ -167,12 +167,12 @@ def test_int_from_address(self):
|
|||
|
||||
# v now is an integer at an 'external' memory location
|
||||
v = t.from_address(a.buffer_info()[0])
|
||||
self.failUnlessEqual(v.value, a[0])
|
||||
self.failUnlessEqual(type(v), t)
|
||||
self.assertEqual(v.value, a[0])
|
||||
self.assertEqual(type(v), t)
|
||||
|
||||
# changing the value at the memory location changes v's value also
|
||||
a[0] = 42
|
||||
self.failUnlessEqual(v.value, a[0])
|
||||
self.assertEqual(v.value, a[0])
|
||||
|
||||
|
||||
def test_float_from_address(self):
|
||||
|
@ -180,11 +180,11 @@ def test_float_from_address(self):
|
|||
for t in float_types:
|
||||
a = array(t._type_, [3.14])
|
||||
v = t.from_address(a.buffer_info()[0])
|
||||
self.failUnlessEqual(v.value, a[0])
|
||||
self.failUnless(type(v) is t)
|
||||
self.assertEqual(v.value, a[0])
|
||||
self.assertTrue(type(v) is t)
|
||||
a[0] = 2.3456e17
|
||||
self.failUnlessEqual(v.value, a[0])
|
||||
self.failUnless(type(v) is t)
|
||||
self.assertEqual(v.value, a[0])
|
||||
self.assertTrue(type(v) is t)
|
||||
|
||||
def test_char_from_address(self):
|
||||
from ctypes import c_char
|
||||
|
@ -193,11 +193,11 @@ def test_char_from_address(self):
|
|||
a = array('b', [0])
|
||||
a[0] = ord('x')
|
||||
v = c_char.from_address(a.buffer_info()[0])
|
||||
self.failUnlessEqual(v.value, b'x')
|
||||
self.failUnless(type(v) is c_char)
|
||||
self.assertEqual(v.value, b'x')
|
||||
self.assertTrue(type(v) is c_char)
|
||||
|
||||
a[0] = ord('?')
|
||||
self.failUnlessEqual(v.value, b'?')
|
||||
self.assertEqual(v.value, b'?')
|
||||
|
||||
# array does not support c_bool / 't'
|
||||
# def test_bool_from_address(self):
|
||||
|
@ -205,11 +205,11 @@ def test_char_from_address(self):
|
|||
# from array import array
|
||||
# a = array(c_bool._type_, [True])
|
||||
# v = t.from_address(a.buffer_info()[0])
|
||||
# self.failUnlessEqual(v.value, a[0])
|
||||
# self.failUnlessEqual(type(v) is t)
|
||||
# self.assertEqual(v.value, a[0])
|
||||
# self.assertEqual(type(v) is t)
|
||||
# a[0] = False
|
||||
# self.failUnlessEqual(v.value, a[0])
|
||||
# self.failUnlessEqual(type(v) is t)
|
||||
# self.assertEqual(v.value, a[0])
|
||||
# self.assertEqual(type(v) is t)
|
||||
|
||||
def test_init(self):
|
||||
# c_int() can be initialized from Python's int, and c_int.
|
||||
|
|
|
@ -33,8 +33,8 @@ def from_param(cls, value):
|
|||
return value * 4
|
||||
from_param = classmethod(from_param)
|
||||
|
||||
self.failUnlessEqual(CVOIDP.from_param("abc"), "abcabc")
|
||||
self.failUnlessEqual(CCHARP.from_param("abc"), "abcabcabcabc")
|
||||
self.assertEqual(CVOIDP.from_param("abc"), "abcabc")
|
||||
self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc")
|
||||
|
||||
try:
|
||||
from ctypes import c_wchar_p
|
||||
|
@ -46,7 +46,7 @@ def from_param(cls, value):
|
|||
return value * 3
|
||||
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
|
||||
def test_cstrings(self):
|
||||
|
@ -55,10 +55,10 @@ def test_cstrings(self):
|
|||
# c_char_p.from_param on a Python String packs the string
|
||||
# into a cparam object
|
||||
s = b"123"
|
||||
self.failUnless(c_char_p.from_param(s)._obj is s)
|
||||
self.assertTrue(c_char_p.from_param(s)._obj is s)
|
||||
|
||||
# new in 0.9.1: convert (encode) unicode to ascii
|
||||
self.failUnlessEqual(c_char_p.from_param("123")._obj, b"123")
|
||||
self.assertEqual(c_char_p.from_param("123")._obj, b"123")
|
||||
self.assertRaises(UnicodeEncodeError, c_char_p.from_param, "123\377")
|
||||
|
||||
self.assertRaises(TypeError, c_char_p.from_param, 42)
|
||||
|
@ -66,7 +66,7 @@ def test_cstrings(self):
|
|||
# calling c_char_p.from_param with a c_char_p instance
|
||||
# returns the argument itself:
|
||||
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):
|
||||
from ctypes import byref
|
||||
|
@ -77,15 +77,15 @@ def test_cw_strings(self):
|
|||
return
|
||||
s = "123"
|
||||
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)
|
||||
|
||||
# new in 0.9.1: convert (decode) ascii to unicode
|
||||
self.failUnlessEqual(c_wchar_p.from_param("123")._obj, "123")
|
||||
self.assertEqual(c_wchar_p.from_param("123")._obj, "123")
|
||||
self.assertRaises(UnicodeDecodeError, c_wchar_p.from_param, b"123\377")
|
||||
|
||||
pa = c_wchar_p.from_param(c_wchar_p("123"))
|
||||
self.failUnlessEqual(type(pa), c_wchar_p)
|
||||
self.assertEqual(type(pa), c_wchar_p)
|
||||
|
||||
def test_int_pointers(self):
|
||||
from ctypes import c_short, c_uint, c_int, c_long, POINTER, pointer
|
||||
|
@ -94,10 +94,10 @@ def test_int_pointers(self):
|
|||
## p = pointer(c_int(42))
|
||||
## x = LPINT.from_param(p)
|
||||
x = LPINT.from_param(pointer(c_int(42)))
|
||||
self.failUnlessEqual(x.contents.value, 42)
|
||||
self.failUnlessEqual(LPINT(c_int(42)).contents.value, 42)
|
||||
self.assertEqual(x.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:
|
||||
self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42)))
|
||||
|
@ -133,8 +133,8 @@ def test_array_pointers(self):
|
|||
from ctypes import c_short, c_uint, c_int, c_long, POINTER
|
||||
INTARRAY = c_int * 3
|
||||
ia = INTARRAY()
|
||||
self.failUnlessEqual(len(ia), 3)
|
||||
self.failUnlessEqual([ia[i] for i in range(3)], [0, 0, 0])
|
||||
self.assertEqual(len(ia), 3)
|
||||
self.assertEqual([ia[i] for i in range(3)], [0, 0, 0])
|
||||
|
||||
# Pointers are only compatible with arrays containing items of
|
||||
# the same type!
|
||||
|
@ -161,8 +161,8 @@ def from_param(cls, obj):
|
|||
return None
|
||||
|
||||
func.argtypes = (Adapter(),)
|
||||
self.failUnlessEqual(func(None), None)
|
||||
self.failUnlessEqual(func(object()), None)
|
||||
self.assertEqual(func(None), None)
|
||||
self.assertEqual(func(object()), None)
|
||||
|
||||
class Adapter(object):
|
||||
def from_param(cls, obj):
|
||||
|
@ -171,7 +171,7 @@ def from_param(cls, obj):
|
|||
func.argtypes = (Adapter(),)
|
||||
# don't know how to convert parameter 1
|
||||
self.assertRaises(ArgumentError, func, object())
|
||||
self.failUnlessEqual(func(c_void_p(42)), 42)
|
||||
self.assertEqual(func(c_void_p(42)), 42)
|
||||
|
||||
class Adapter(object):
|
||||
def from_param(cls, obj):
|
||||
|
|
|
@ -24,23 +24,23 @@ def test_native_types(self):
|
|||
ob = tp()
|
||||
v = memoryview(ob)
|
||||
try:
|
||||
self.failUnlessEqual(normalize(v.format), normalize(fmt))
|
||||
self.assertEqual(normalize(v.format), normalize(fmt))
|
||||
if shape is not None:
|
||||
self.failUnlessEqual(len(v), shape[0])
|
||||
self.assertEqual(len(v), shape[0])
|
||||
else:
|
||||
self.failUnlessEqual(len(v) * sizeof(itemtp), sizeof(ob))
|
||||
self.failUnlessEqual(v.itemsize, sizeof(itemtp))
|
||||
self.failUnlessEqual(v.shape, shape)
|
||||
self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
|
||||
self.assertEqual(v.itemsize, sizeof(itemtp))
|
||||
self.assertEqual(v.shape, shape)
|
||||
# ctypes object always have a non-strided memory block
|
||||
self.failUnlessEqual(v.strides, None)
|
||||
self.assertEqual(v.strides, None)
|
||||
# they are always read/write
|
||||
self.failIf(v.readonly)
|
||||
self.assertFalse(v.readonly)
|
||||
|
||||
if v.shape:
|
||||
n = 1
|
||||
for dim in v.shape:
|
||||
n = n * dim
|
||||
self.failUnlessEqual(n * v.itemsize, len(v.tobytes()))
|
||||
self.assertEqual(n * v.itemsize, len(v.tobytes()))
|
||||
except:
|
||||
# so that we can see the failing type
|
||||
print(tp)
|
||||
|
@ -51,23 +51,23 @@ def test_endian_types(self):
|
|||
ob = tp()
|
||||
v = memoryview(ob)
|
||||
try:
|
||||
self.failUnlessEqual(v.format, fmt)
|
||||
self.assertEqual(v.format, fmt)
|
||||
if shape is not None:
|
||||
self.failUnlessEqual(len(v), shape[0])
|
||||
self.assertEqual(len(v), shape[0])
|
||||
else:
|
||||
self.failUnlessEqual(len(v) * sizeof(itemtp), sizeof(ob))
|
||||
self.failUnlessEqual(v.itemsize, sizeof(itemtp))
|
||||
self.failUnlessEqual(v.shape, shape)
|
||||
self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
|
||||
self.assertEqual(v.itemsize, sizeof(itemtp))
|
||||
self.assertEqual(v.shape, shape)
|
||||
# ctypes object always have a non-strided memory block
|
||||
self.failUnlessEqual(v.strides, None)
|
||||
self.assertEqual(v.strides, None)
|
||||
# they are always read/write
|
||||
self.failIf(v.readonly)
|
||||
self.assertFalse(v.readonly)
|
||||
|
||||
if v.shape:
|
||||
n = 1
|
||||
for dim in v.shape:
|
||||
n = n * dim
|
||||
self.failUnlessEqual(n, len(v))
|
||||
self.assertEqual(n, len(v))
|
||||
except:
|
||||
# so that we can see the failing type
|
||||
print(tp)
|
||||
|
|
|
@ -27,8 +27,8 @@ def test_simple(self):
|
|||
c_double(3.14),
|
||||
]:
|
||||
dst = self.loads(self.dumps(src))
|
||||
self.failUnlessEqual(src.__dict__, dst.__dict__)
|
||||
self.failUnlessEqual(memoryview(src).tobytes(),
|
||||
self.assertEqual(src.__dict__, dst.__dict__)
|
||||
self.assertEqual(memoryview(src).tobytes(),
|
||||
memoryview(dst).tobytes())
|
||||
|
||||
def test_struct(self):
|
||||
|
@ -36,17 +36,17 @@ def test_struct(self):
|
|||
|
||||
x = X()
|
||||
x.a = 42
|
||||
self.failUnlessEqual(X.init_called, 1)
|
||||
self.assertEqual(X.init_called, 1)
|
||||
|
||||
y = self.loads(self.dumps(x))
|
||||
|
||||
# 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__
|
||||
# and the memory buffer are identical
|
||||
self.failUnlessEqual(y.__dict__, x.__dict__)
|
||||
self.failUnlessEqual(memoryview(y).tobytes(),
|
||||
self.assertEqual(y.__dict__, x.__dict__)
|
||||
self.assertEqual(memoryview(y).tobytes(),
|
||||
memoryview(x).tobytes())
|
||||
|
||||
def test_unpickable(self):
|
||||
|
|
|
@ -17,7 +17,7 @@ class A(POINTER(c_ulong)):
|
|||
|
||||
POINTER(c_ulong)(c_ulong(22))
|
||||
# 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):
|
||||
dll = CDLL(_ctypes_test.__file__)
|
||||
|
@ -27,12 +27,12 @@ def test_pass_pointers(self):
|
|||
i = c_int(12345678)
|
||||
## func.argtypes = (POINTER(c_int),)
|
||||
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)
|
||||
res = func(pointer(i))
|
||||
self.failUnlessEqual(res.contents.value, 12345678)
|
||||
self.failUnlessEqual(res[0], 12345678)
|
||||
self.assertEqual(res.contents.value, 12345678)
|
||||
self.assertEqual(res[0], 12345678)
|
||||
|
||||
def test_change_pointers(self):
|
||||
dll = CDLL(_ctypes_test.__file__)
|
||||
|
@ -43,18 +43,18 @@ def test_change_pointers(self):
|
|||
func.argtypes = (POINTER(c_int),)
|
||||
|
||||
res = func(pointer(i))
|
||||
self.failUnlessEqual(res[0], 87654)
|
||||
self.failUnlessEqual(res.contents.value, 87654)
|
||||
self.assertEqual(res[0], 87654)
|
||||
self.assertEqual(res.contents.value, 87654)
|
||||
|
||||
# C code: *res = 54345
|
||||
res[0] = 54345
|
||||
self.failUnlessEqual(i.value, 54345)
|
||||
self.assertEqual(i.value, 54345)
|
||||
|
||||
# C code:
|
||||
# int x = 12321;
|
||||
# res = &x
|
||||
res.contents = c_int(12321)
|
||||
self.failUnlessEqual(i.value, 54345)
|
||||
self.assertEqual(i.value, 54345)
|
||||
|
||||
def test_callbacks_with_pointers(self):
|
||||
# a function type receiving a pointer
|
||||
|
@ -78,7 +78,7 @@ def func(arg):
|
|||
|
||||
## i = c_int(42)
|
||||
## callback(byref(i))
|
||||
## self.failUnless(i.value == 84)
|
||||
## self.assertTrue(i.value == 84)
|
||||
|
||||
doit(callback)
|
||||
## print self.result
|
||||
|
@ -91,11 +91,11 @@ def test_basics(self):
|
|||
i = ct(42)
|
||||
p = pointer(i)
|
||||
## 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]
|
||||
## print p.contents
|
||||
## self.failUnless(p.contents == 42)
|
||||
## self.failUnless(p[0] == 42)
|
||||
## self.assertTrue(p.contents == 42)
|
||||
## self.assertTrue(p[0] == 42)
|
||||
|
||||
self.assertRaises(TypeError, delitem, p, 0)
|
||||
|
||||
|
@ -117,9 +117,9 @@ class Table(Structure):
|
|||
|
||||
pt = pointer(Table(1, 2, 3))
|
||||
|
||||
self.failUnlessEqual(pt.contents.a, 1)
|
||||
self.failUnlessEqual(pt.contents.b, 2)
|
||||
self.failUnlessEqual(pt.contents.c, 3)
|
||||
self.assertEqual(pt.contents.a, 1)
|
||||
self.assertEqual(pt.contents.b, 2)
|
||||
self.assertEqual(pt.contents.c, 3)
|
||||
|
||||
pt.contents.c = 33
|
||||
|
||||
|
@ -130,8 +130,8 @@ def test_basic(self):
|
|||
p = pointer(c_int(42))
|
||||
# Although a pointer can be indexed, it ha no length
|
||||
self.assertRaises(TypeError, len, p)
|
||||
self.failUnlessEqual(p[0], 42)
|
||||
self.failUnlessEqual(p.contents.value, 42)
|
||||
self.assertEqual(p[0], 42)
|
||||
self.assertEqual(p.contents.value, 42)
|
||||
|
||||
def test_charpp(self):
|
||||
"""Test that a character pointer-to-pointer is correctly passed"""
|
||||
|
@ -156,20 +156,20 @@ def test_bug_1467852(self):
|
|||
pp = pointer(p)
|
||||
q = pointer(y)
|
||||
pp[0] = q # <==
|
||||
self.failUnlessEqual(p[0], 6)
|
||||
self.assertEqual(p[0], 6)
|
||||
def test_c_void_p(self):
|
||||
# http://sourceforge.net/tracker/?func=detail&aid=1518190&group_id=5470&atid=105470
|
||||
if sizeof(c_void_p) == 4:
|
||||
self.failUnlessEqual(c_void_p(0xFFFFFFFF).value,
|
||||
self.assertEqual(c_void_p(0xFFFFFFFF).value,
|
||||
c_void_p(-1).value)
|
||||
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
|
||||
self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
|
||||
c_void_p(-1).value)
|
||||
elif sizeof(c_void_p) == 8:
|
||||
self.failUnlessEqual(c_void_p(0xFFFFFFFF).value,
|
||||
self.assertEqual(c_void_p(0xFFFFFFFF).value,
|
||||
0xFFFFFFFF)
|
||||
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
|
||||
self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
|
||||
c_void_p(-1).value)
|
||||
self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value,
|
||||
self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value,
|
||||
c_void_p(-1).value)
|
||||
|
||||
self.assertRaises(TypeError, c_void_p, 3.14) # make sure floats are NOT accepted
|
||||
|
@ -177,16 +177,16 @@ def test_c_void_p(self):
|
|||
|
||||
def test_pointers_bool(self):
|
||||
# NULL pointers have a boolean False value, non-NULL pointers True.
|
||||
self.failUnlessEqual(bool(POINTER(c_int)()), False)
|
||||
self.failUnlessEqual(bool(pointer(c_int())), True)
|
||||
self.assertEqual(bool(POINTER(c_int)()), False)
|
||||
self.assertEqual(bool(pointer(c_int())), True)
|
||||
|
||||
self.failUnlessEqual(bool(CFUNCTYPE(None)(0)), False)
|
||||
self.failUnlessEqual(bool(CFUNCTYPE(None)(42)), True)
|
||||
self.assertEqual(bool(CFUNCTYPE(None)(0)), False)
|
||||
self.assertEqual(bool(CFUNCTYPE(None)(42)), True)
|
||||
|
||||
# COM methods are boolean True:
|
||||
if sys.platform == "win32":
|
||||
mth = WINFUNCTYPE(None)(42, "name", (), None)
|
||||
self.failUnlessEqual(bool(mth), True)
|
||||
self.assertEqual(bool(mth), True)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
|
@ -58,23 +58,23 @@ def test_paramflags(self):
|
|||
try:
|
||||
func()
|
||||
except TypeError as details:
|
||||
self.failUnlessEqual(str(details), "required argument 'input' missing")
|
||||
self.assertEqual(str(details), "required argument 'input' missing")
|
||||
else:
|
||||
self.fail("TypeError not raised")
|
||||
|
||||
self.failUnlessEqual(func(None), None)
|
||||
self.failUnlessEqual(func(input=None), None)
|
||||
self.assertEqual(func(None), None)
|
||||
self.assertEqual(func(input=None), None)
|
||||
|
||||
|
||||
def test_int_pointer_arg(self):
|
||||
func = testdll._testfunc_p_p
|
||||
func.restype = c_long
|
||||
self.failUnlessEqual(0, func(0))
|
||||
self.assertEqual(0, func(0))
|
||||
|
||||
ci = c_int(0)
|
||||
|
||||
func.argtypes = POINTER(c_int),
|
||||
self.failUnlessEqual(positive_address(addressof(ci)),
|
||||
self.assertEqual(positive_address(addressof(ci)),
|
||||
positive_address(func(byref(ci))))
|
||||
|
||||
func.argtypes = c_char_p,
|
||||
|
@ -91,45 +91,45 @@ def test_POINTER_c_char_arg(self):
|
|||
func.restype = c_char_p
|
||||
func.argtypes = POINTER(c_char),
|
||||
|
||||
self.failUnlessEqual(None, func(None))
|
||||
self.failUnlessEqual("123", func("123"))
|
||||
self.failUnlessEqual(None, func(c_char_p(None)))
|
||||
self.failUnlessEqual("123", func(c_char_p("123")))
|
||||
self.assertEqual(None, func(None))
|
||||
self.assertEqual("123", func("123"))
|
||||
self.assertEqual(None, func(c_char_p(None)))
|
||||
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")
|
||||
self.failUnlessEqual("a", func(pointer(ca))[0])
|
||||
self.failUnlessEqual("a", func(byref(ca))[0])
|
||||
self.assertEqual("a", func(pointer(ca))[0])
|
||||
self.assertEqual("a", func(byref(ca))[0])
|
||||
|
||||
def test_c_char_p_arg(self):
|
||||
func = testdll._testfunc_p_p
|
||||
func.restype = c_char_p
|
||||
func.argtypes = c_char_p,
|
||||
|
||||
self.failUnlessEqual(None, func(None))
|
||||
self.failUnlessEqual("123", func("123"))
|
||||
self.failUnlessEqual(None, func(c_char_p(None)))
|
||||
self.failUnlessEqual("123", func(c_char_p("123")))
|
||||
self.assertEqual(None, func(None))
|
||||
self.assertEqual("123", func("123"))
|
||||
self.assertEqual(None, func(c_char_p(None)))
|
||||
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")
|
||||
self.failUnlessEqual("a", func(pointer(ca))[0])
|
||||
self.failUnlessEqual("a", func(byref(ca))[0])
|
||||
self.assertEqual("a", func(pointer(ca))[0])
|
||||
self.assertEqual("a", func(byref(ca))[0])
|
||||
|
||||
def test_c_void_p_arg(self):
|
||||
func = testdll._testfunc_p_p
|
||||
func.restype = c_char_p
|
||||
func.argtypes = c_void_p,
|
||||
|
||||
self.failUnlessEqual(None, func(None))
|
||||
self.failUnlessEqual("123", func(b"123"))
|
||||
self.failUnlessEqual("123", func(c_char_p("123")))
|
||||
self.failUnlessEqual(None, func(c_char_p(None)))
|
||||
self.assertEqual(None, func(None))
|
||||
self.assertEqual("123", func(b"123"))
|
||||
self.assertEqual("123", func(c_char_p("123")))
|
||||
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")
|
||||
self.failUnlessEqual("a", func(pointer(ca))[0])
|
||||
self.failUnlessEqual("a", func(byref(ca))[0])
|
||||
self.assertEqual("a", func(pointer(ca))[0])
|
||||
self.assertEqual("a", func(byref(ca))[0])
|
||||
|
||||
func(byref(c_int()))
|
||||
func(pointer(c_int()))
|
||||
|
@ -140,8 +140,8 @@ def test_c_void_p_arg(self):
|
|||
except NameError:
|
||||
pass
|
||||
else:
|
||||
self.failUnlessEqual(None, func(c_wchar_p(None)))
|
||||
self.failUnlessEqual("123", func(c_wchar_p("123")))
|
||||
self.assertEqual(None, func(c_wchar_p(None)))
|
||||
self.assertEqual("123", func(c_wchar_p("123")))
|
||||
|
||||
def test_instance(self):
|
||||
func = testdll._testfunc_p_p
|
||||
|
@ -151,10 +151,10 @@ class X:
|
|||
_as_parameter_ = None
|
||||
|
||||
func.argtypes = c_void_p,
|
||||
self.failUnlessEqual(None, func(X()))
|
||||
self.assertEqual(None, func(X()))
|
||||
|
||||
func.argtypes = None
|
||||
self.failUnlessEqual(None, func(X()))
|
||||
self.assertEqual(None, func(X()))
|
||||
|
||||
try:
|
||||
c_wchar
|
||||
|
@ -174,15 +174,15 @@ def test_POINTER_c_wchar_arg(self):
|
|||
func.restype = c_wchar_p
|
||||
func.argtypes = POINTER(c_wchar),
|
||||
|
||||
self.failUnlessEqual(None, func(None))
|
||||
self.failUnlessEqual("123", func("123"))
|
||||
self.failUnlessEqual(None, func(c_wchar_p(None)))
|
||||
self.failUnlessEqual("123", func(c_wchar_p("123")))
|
||||
self.assertEqual(None, func(None))
|
||||
self.assertEqual("123", func("123"))
|
||||
self.assertEqual(None, func(c_wchar_p(None)))
|
||||
self.assertEqual("123", func(c_wchar_p("123")))
|
||||
|
||||
self.failUnlessEqual("123", func(c_wbuffer("123")))
|
||||
self.assertEqual("123", func(c_wbuffer("123")))
|
||||
ca = c_wchar("a")
|
||||
self.failUnlessEqual("a", func(pointer(ca))[0])
|
||||
self.failUnlessEqual("a", func(byref(ca))[0])
|
||||
self.assertEqual("a", func(pointer(ca))[0])
|
||||
self.assertEqual("a", func(byref(ca))[0])
|
||||
|
||||
def test_c_wchar_p_arg(self):
|
||||
func = testdll._testfunc_p_p
|
||||
|
@ -191,16 +191,16 @@ def test_c_wchar_p_arg(self):
|
|||
|
||||
c_wchar_p.from_param("123")
|
||||
|
||||
self.failUnlessEqual(None, func(None))
|
||||
self.failUnlessEqual("123", func("123"))
|
||||
self.failUnlessEqual(None, func(c_wchar_p(None)))
|
||||
self.failUnlessEqual("123", func(c_wchar_p("123")))
|
||||
self.assertEqual(None, func(None))
|
||||
self.assertEqual("123", func("123"))
|
||||
self.assertEqual(None, func(c_wchar_p(None)))
|
||||
self.assertEqual("123", func(c_wchar_p("123")))
|
||||
|
||||
# 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")
|
||||
self.failUnlessEqual("a", func(pointer(ca))[0])
|
||||
self.failUnlessEqual("a", func(byref(ca))[0])
|
||||
self.assertEqual("a", func(pointer(ca))[0])
|
||||
self.assertEqual("a", func(byref(ca))[0])
|
||||
|
||||
class ArrayTest(unittest.TestCase):
|
||||
def test(self):
|
||||
|
|
|
@ -23,7 +23,7 @@ def test_PyBytes_FromStringAndSize(self):
|
|||
PyBytes_FromStringAndSize.restype = py_object
|
||||
PyBytes_FromStringAndSize.argtypes = c_char_p, c_py_ssize_t
|
||||
|
||||
self.failUnlessEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
|
||||
self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
|
||||
|
||||
def test_PyString_FromString(self):
|
||||
pythonapi.PyBytes_FromString.restype = py_object
|
||||
|
@ -32,10 +32,10 @@ def test_PyString_FromString(self):
|
|||
s = b"abc"
|
||||
refcnt = grc(s)
|
||||
pyob = pythonapi.PyBytes_FromString(s)
|
||||
self.failUnlessEqual(grc(s), refcnt)
|
||||
self.failUnlessEqual(s, pyob)
|
||||
self.assertEqual(grc(s), refcnt)
|
||||
self.assertEqual(s, pyob)
|
||||
del pyob
|
||||
self.failUnlessEqual(grc(s), refcnt)
|
||||
self.assertEqual(grc(s), refcnt)
|
||||
|
||||
if is_resource_enabled("refcount"):
|
||||
# This test is unreliable, because it is possible that code in
|
||||
|
@ -44,28 +44,28 @@ def test_PyString_FromString(self):
|
|||
def test_PyLong_Long(self):
|
||||
ref42 = grc(42)
|
||||
pythonapi.PyLong_FromLong.restype = py_object
|
||||
self.failUnlessEqual(pythonapi.PyLong_FromLong(42), 42)
|
||||
self.assertEqual(pythonapi.PyLong_FromLong(42), 42)
|
||||
|
||||
self.failUnlessEqual(grc(42), ref42)
|
||||
self.assertEqual(grc(42), ref42)
|
||||
|
||||
pythonapi.PyLong_AsLong.argtypes = (py_object,)
|
||||
pythonapi.PyLong_AsLong.restype = c_long
|
||||
|
||||
res = pythonapi.PyLong_AsLong(42)
|
||||
self.failUnlessEqual(grc(res), ref42 + 1)
|
||||
self.assertEqual(grc(res), ref42 + 1)
|
||||
del res
|
||||
self.failUnlessEqual(grc(42), ref42)
|
||||
self.assertEqual(grc(42), ref42)
|
||||
|
||||
def test_PyObj_FromPtr(self):
|
||||
s = "abc def ghi jkl"
|
||||
ref = grc(s)
|
||||
# id(python-object) is the address
|
||||
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
|
||||
self.failUnlessEqual(grc(s), ref)
|
||||
self.assertEqual(grc(s), ref)
|
||||
|
||||
def test_PyOS_snprintf(self):
|
||||
PyOS_snprintf = pythonapi.PyOS_snprintf
|
||||
|
@ -73,18 +73,18 @@ def test_PyOS_snprintf(self):
|
|||
|
||||
buf = c_buffer(256)
|
||||
PyOS_snprintf(buf, sizeof(buf), "Hello from %s", b"ctypes")
|
||||
self.failUnlessEqual(buf.value, b"Hello from ctypes")
|
||||
self.assertEqual(buf.value, b"Hello from ctypes")
|
||||
|
||||
PyOS_snprintf(buf, sizeof(buf), "Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3)
|
||||
self.failUnlessEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
|
||||
self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
|
||||
|
||||
# not enough arguments
|
||||
self.failUnlessRaises(TypeError, PyOS_snprintf, buf)
|
||||
self.assertRaises(TypeError, PyOS_snprintf, buf)
|
||||
|
||||
def test_pyobject_repr(self):
|
||||
self.failUnlessEqual(repr(py_object()), "py_object(<NULL>)")
|
||||
self.failUnlessEqual(repr(py_object(42)), "py_object(42)")
|
||||
self.failUnlessEqual(repr(py_object(object)), "py_object(%r)" % object)
|
||||
self.assertEqual(repr(py_object()), "py_object(<NULL>)")
|
||||
self.assertEqual(repr(py_object(42)), "py_object(42)")
|
||||
self.assertEqual(repr(py_object(object)), "py_object(%r)" % object)
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -20,7 +20,7 @@ def test(self):
|
|||
hdll = windll.kernel32.LoadLibraryA(b"kernel32")
|
||||
funcaddr = windll.kernel32.GetProcAddress(hdll, "GetModuleHandleA")
|
||||
|
||||
self.failUnlessEqual(call_function(funcaddr, (None,)),
|
||||
self.assertEqual(call_function(funcaddr, (None,)),
|
||||
windll.kernel32.GetModuleHandleA(None))
|
||||
|
||||
class CallbackTracbackTestCase(unittest.TestCase):
|
||||
|
@ -49,25 +49,25 @@ def capture_stderr(self, func, *args, **kw):
|
|||
def test_ValueError(self):
|
||||
cb = CFUNCTYPE(c_int, c_int)(callback_func)
|
||||
out = self.capture_stderr(cb, 42)
|
||||
self.failUnlessEqual(out.splitlines()[-1],
|
||||
self.assertEqual(out.splitlines()[-1],
|
||||
"ValueError: 42")
|
||||
|
||||
def test_IntegerDivisionError(self):
|
||||
cb = CFUNCTYPE(c_int, c_int)(callback_func)
|
||||
out = self.capture_stderr(cb, 0)
|
||||
self.failUnlessEqual(out.splitlines()[-1][:19],
|
||||
self.assertEqual(out.splitlines()[-1][:19],
|
||||
"ZeroDivisionError: ")
|
||||
|
||||
def test_FloatDivisionError(self):
|
||||
cb = CFUNCTYPE(c_int, c_double)(callback_func)
|
||||
out = self.capture_stderr(cb, 0.0)
|
||||
self.failUnlessEqual(out.splitlines()[-1][:19],
|
||||
self.assertEqual(out.splitlines()[-1][:19],
|
||||
"ZeroDivisionError: ")
|
||||
|
||||
def test_TypeErrorDivisionError(self):
|
||||
cb = CFUNCTYPE(c_int, c_char_p)(callback_func)
|
||||
out = self.capture_stderr(cb, "spam")
|
||||
self.failUnlessEqual(out.splitlines()[-1],
|
||||
self.assertEqual(out.splitlines()[-1],
|
||||
"TypeError: "
|
||||
"unsupported operand type(s) for /: 'int' and 'str'")
|
||||
|
||||
|
|
|
@ -21,17 +21,17 @@ def callback(value):
|
|||
#print "called back with", value
|
||||
return value
|
||||
|
||||
self.failUnlessEqual(grc(callback), 2)
|
||||
self.assertEqual(grc(callback), 2)
|
||||
cb = MyCallback(callback)
|
||||
|
||||
self.failUnless(grc(callback) > 2)
|
||||
self.assertTrue(grc(callback) > 2)
|
||||
result = f(-10, cb)
|
||||
self.failUnlessEqual(result, -18)
|
||||
self.assertEqual(result, -18)
|
||||
cb = None
|
||||
|
||||
gc.collect()
|
||||
|
||||
self.failUnlessEqual(grc(callback), 2)
|
||||
self.assertEqual(grc(callback), 2)
|
||||
|
||||
|
||||
def test_refcount(self):
|
||||
|
@ -39,19 +39,19 @@ def test_refcount(self):
|
|||
def func(*args):
|
||||
pass
|
||||
# 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:
|
||||
f = OtherCallback(func)
|
||||
self.failUnless(grc(func) > 2)
|
||||
self.assertTrue(grc(func) > 2)
|
||||
|
||||
# and may release it again
|
||||
del f
|
||||
self.failUnless(grc(func) >= 2)
|
||||
self.assertTrue(grc(func) >= 2)
|
||||
|
||||
# but now it must be gone
|
||||
gc.collect()
|
||||
self.failUnless(grc(func) == 2)
|
||||
self.assertTrue(grc(func) == 2)
|
||||
|
||||
class X(ctypes.Structure):
|
||||
_fields_ = [("a", OtherCallback)]
|
||||
|
@ -59,27 +59,27 @@ class X(ctypes.Structure):
|
|||
x.a = OtherCallback(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
|
||||
del x
|
||||
self.failUnless(grc(func) >= 2)
|
||||
self.assertTrue(grc(func) >= 2)
|
||||
|
||||
# and now it must be gone again
|
||||
gc.collect()
|
||||
self.failUnlessEqual(grc(func), 2)
|
||||
self.assertEqual(grc(func), 2)
|
||||
|
||||
f = OtherCallback(func)
|
||||
|
||||
# the CFuncPtr instance holds atr least one refcount on func:
|
||||
self.failUnless(grc(func) > 2)
|
||||
self.assertTrue(grc(func) > 2)
|
||||
|
||||
# create a cycle
|
||||
f.cycle = f
|
||||
|
||||
del f
|
||||
gc.collect()
|
||||
self.failUnlessEqual(grc(func), 2)
|
||||
self.assertEqual(grc(func), 2)
|
||||
|
||||
class AnotherLeak(unittest.TestCase):
|
||||
def test_callback(self):
|
||||
|
@ -92,7 +92,7 @@ def func(a, b):
|
|||
|
||||
a = sys.getrefcount(ctypes.c_int)
|
||||
f(1, 2)
|
||||
self.failUnlessEqual(sys.getrefcount(ctypes.c_int), a)
|
||||
self.assertEqual(sys.getrefcount(ctypes.c_int), a)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
|
@ -18,12 +18,12 @@ class ReprTest(unittest.TestCase):
|
|||
def test_numbers(self):
|
||||
for typ in subclasses:
|
||||
base = typ.__bases__[0]
|
||||
self.failUnless(repr(base(42)).startswith(base.__name__))
|
||||
self.failUnlessEqual("<X object at", repr(typ(42))[:12])
|
||||
self.assertTrue(repr(base(42)).startswith(base.__name__))
|
||||
self.assertEqual("<X object at", repr(typ(42))[:12])
|
||||
|
||||
def test_char(self):
|
||||
self.failUnlessEqual("c_char(b'x')", repr(c_char('x')))
|
||||
self.failUnlessEqual("<X object at", repr(X('x'))[:12])
|
||||
self.assertEqual("c_char(b'x')", repr(c_char('x')))
|
||||
self.assertEqual("<X object at", repr(X('x'))[:12])
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -12,10 +12,10 @@ def test_with_prototype(self):
|
|||
get_strchr = dll.get_strchr
|
||||
get_strchr.restype = CFUNCTYPE(c_char_p, c_char_p, c_char)
|
||||
strchr = get_strchr()
|
||||
self.failUnlessEqual(strchr("abcdef", "b"), "bcdef")
|
||||
self.failUnlessEqual(strchr("abcdef", "x"), None)
|
||||
self.failUnlessEqual(strchr("abcdef", 98), "bcdef")
|
||||
self.failUnlessEqual(strchr("abcdef", 107), None)
|
||||
self.assertEqual(strchr("abcdef", "b"), "bcdef")
|
||||
self.assertEqual(strchr("abcdef", "x"), None)
|
||||
self.assertEqual(strchr("abcdef", 98), "bcdef")
|
||||
self.assertEqual(strchr("abcdef", 107), None)
|
||||
self.assertRaises(ArgumentError, strchr, "abcdef", 3.0)
|
||||
self.assertRaises(TypeError, strchr, "abcdef")
|
||||
|
||||
|
@ -28,8 +28,8 @@ def test_without_prototype(self):
|
|||
# _CFuncPtr instances are now callable with an integer argument
|
||||
# which denotes a function address:
|
||||
strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(addr)
|
||||
self.failUnless(strchr("abcdef", "b"), "bcdef")
|
||||
self.failUnlessEqual(strchr("abcdef", "x"), None)
|
||||
self.assertTrue(strchr("abcdef", "b"), "bcdef")
|
||||
self.assertEqual(strchr("abcdef", "x"), None)
|
||||
self.assertRaises(ArgumentError, strchr, "abcdef", 3.0)
|
||||
self.assertRaises(TypeError, strchr, "abcdef")
|
||||
|
||||
|
|
|
@ -10,8 +10,8 @@ def __eq__(self, other):
|
|||
class Test(unittest.TestCase):
|
||||
|
||||
def test_compare(self):
|
||||
self.failUnlessEqual(MyInt(3), MyInt(3))
|
||||
self.failIfEqual(MyInt(42), MyInt(43))
|
||||
self.assertEqual(MyInt(3), MyInt(3))
|
||||
self.assertNotEqual(MyInt(42), MyInt(43))
|
||||
|
||||
def test_ignore_retval(self):
|
||||
# Test if the return value of a callback is ignored
|
||||
|
@ -21,7 +21,7 @@ def func():
|
|||
return (1, "abc", None)
|
||||
|
||||
cb = proto(func)
|
||||
self.failUnlessEqual(None, cb())
|
||||
self.assertEqual(None, cb())
|
||||
|
||||
|
||||
def test_int_callback(self):
|
||||
|
@ -32,24 +32,24 @@ def func(arg):
|
|||
|
||||
cb = CFUNCTYPE(None, MyInt)(func)
|
||||
|
||||
self.failUnlessEqual(None, cb(42))
|
||||
self.failUnlessEqual(type(args[-1]), MyInt)
|
||||
self.assertEqual(None, cb(42))
|
||||
self.assertEqual(type(args[-1]), MyInt)
|
||||
|
||||
cb = CFUNCTYPE(c_int, c_int)(func)
|
||||
|
||||
self.failUnlessEqual(42, cb(42))
|
||||
self.failUnlessEqual(type(args[-1]), int)
|
||||
self.assertEqual(42, cb(42))
|
||||
self.assertEqual(type(args[-1]), int)
|
||||
|
||||
def test_int_struct(self):
|
||||
class X(Structure):
|
||||
_fields_ = [("x", MyInt)]
|
||||
|
||||
self.failUnlessEqual(X().x, MyInt())
|
||||
self.assertEqual(X().x, MyInt())
|
||||
|
||||
s = X()
|
||||
s.x = MyInt(42)
|
||||
|
||||
self.failUnlessEqual(s.x, MyInt(42))
|
||||
self.assertEqual(s.x, MyInt(42))
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -5,23 +5,23 @@
|
|||
|
||||
class SizesTestCase(unittest.TestCase):
|
||||
def test_8(self):
|
||||
self.failUnlessEqual(1, sizeof(c_int8))
|
||||
self.failUnlessEqual(1, sizeof(c_uint8))
|
||||
self.assertEqual(1, sizeof(c_int8))
|
||||
self.assertEqual(1, sizeof(c_uint8))
|
||||
|
||||
def test_16(self):
|
||||
self.failUnlessEqual(2, sizeof(c_int16))
|
||||
self.failUnlessEqual(2, sizeof(c_uint16))
|
||||
self.assertEqual(2, sizeof(c_int16))
|
||||
self.assertEqual(2, sizeof(c_uint16))
|
||||
|
||||
def test_32(self):
|
||||
self.failUnlessEqual(4, sizeof(c_int32))
|
||||
self.failUnlessEqual(4, sizeof(c_uint32))
|
||||
self.assertEqual(4, sizeof(c_int32))
|
||||
self.assertEqual(4, sizeof(c_uint32))
|
||||
|
||||
def test_64(self):
|
||||
self.failUnlessEqual(8, sizeof(c_int64))
|
||||
self.failUnlessEqual(8, sizeof(c_uint64))
|
||||
self.assertEqual(8, sizeof(c_int64))
|
||||
self.assertEqual(8, sizeof(c_uint64))
|
||||
|
||||
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__":
|
||||
unittest.main()
|
||||
|
|
|
@ -7,43 +7,43 @@ class SlicesTestCase(unittest.TestCase):
|
|||
def test_getslice_cint(self):
|
||||
a = (c_int * 100)(*range(1100, 1200))
|
||||
b = list(range(1100, 1200))
|
||||
self.failUnlessEqual(a[0:2], b[0:2])
|
||||
self.failUnlessEqual(a[0:2:], b[0:2:])
|
||||
self.failUnlessEqual(len(a), len(b))
|
||||
self.failUnlessEqual(a[5:7], b[5:7])
|
||||
self.failUnlessEqual(a[5:7:], b[5:7:])
|
||||
self.failUnlessEqual(a[-1], b[-1])
|
||||
self.failUnlessEqual(a[:], b[:])
|
||||
self.failUnlessEqual(a[::], b[::])
|
||||
self.failUnlessEqual(a[10::-1], b[10::-1])
|
||||
self.failUnlessEqual(a[30:20:-1], b[30:20:-1])
|
||||
self.failUnlessEqual(a[:12:6], b[:12:6])
|
||||
self.failUnlessEqual(a[2:6:4], b[2:6:4])
|
||||
self.assertEqual(a[0:2], b[0:2])
|
||||
self.assertEqual(a[0:2:], b[0:2:])
|
||||
self.assertEqual(len(a), len(b))
|
||||
self.assertEqual(a[5:7], b[5:7])
|
||||
self.assertEqual(a[5:7:], b[5:7:])
|
||||
self.assertEqual(a[-1], b[-1])
|
||||
self.assertEqual(a[:], b[:])
|
||||
self.assertEqual(a[::], b[::])
|
||||
self.assertEqual(a[10::-1], b[10::-1])
|
||||
self.assertEqual(a[30:20:-1], b[30:20:-1])
|
||||
self.assertEqual(a[:12:6], b[:12:6])
|
||||
self.assertEqual(a[2:6:4], b[2:6:4])
|
||||
|
||||
a[0:5] = range(5, 10)
|
||||
self.failUnlessEqual(a[0:5], list(range(5, 10)))
|
||||
self.failUnlessEqual(a[0:5:], list(range(5, 10)))
|
||||
self.failUnlessEqual(a[4::-1], list(range(9, 4, -1)))
|
||||
self.assertEqual(a[0:5], list(range(5, 10)))
|
||||
self.assertEqual(a[0:5:], list(range(5, 10)))
|
||||
self.assertEqual(a[4::-1], list(range(9, 4, -1)))
|
||||
|
||||
def test_setslice_cint(self):
|
||||
a = (c_int * 100)(*range(1100, 1200))
|
||||
b = list(range(1100, 1200))
|
||||
|
||||
a[32:47] = list(range(32, 47))
|
||||
self.failUnlessEqual(a[32:47], list(range(32, 47)))
|
||||
self.assertEqual(a[32:47], list(range(32, 47)))
|
||||
a[32:47] = range(132, 147)
|
||||
self.failUnlessEqual(a[32:47:], list(range(132, 147)))
|
||||
self.assertEqual(a[32:47:], list(range(132, 147)))
|
||||
a[46:31:-1] = range(232, 247)
|
||||
self.failUnlessEqual(a[32:47:1], list(range(246, 231, -1)))
|
||||
self.assertEqual(a[32:47:1], list(range(246, 231, -1)))
|
||||
|
||||
a[32:47] = range(1132, 1147)
|
||||
self.failUnlessEqual(a[:], b)
|
||||
self.assertEqual(a[:], b)
|
||||
a[32:47:7] = range(3)
|
||||
b[32:47:7] = range(3)
|
||||
self.failUnlessEqual(a[:], b)
|
||||
self.assertEqual(a[:], b)
|
||||
a[33::-3] = range(12)
|
||||
b[33::-3] = range(12)
|
||||
self.failUnlessEqual(a[:], b)
|
||||
self.assertEqual(a[:], b)
|
||||
|
||||
from operator import setitem
|
||||
|
||||
|
@ -65,12 +65,12 @@ def test_char_ptr(self):
|
|||
dll.my_strdup.restype = POINTER(c_char)
|
||||
dll.my_free.restype = None
|
||||
res = dll.my_strdup(s)
|
||||
self.failUnlessEqual(res[:len(s)], s)
|
||||
self.failUnlessEqual(res[:3], s[:3])
|
||||
self.failUnlessEqual(res[:len(s):], s)
|
||||
self.failUnlessEqual(res[len(s)-1:-1:-1], s[::-1])
|
||||
self.failUnlessEqual(res[len(s)-1:5:-7], s[:5:-7])
|
||||
self.failUnlessEqual(res[0:-1:-1], s[0::-1])
|
||||
self.assertEqual(res[:len(s)], s)
|
||||
self.assertEqual(res[:3], s[:3])
|
||||
self.assertEqual(res[:len(s):], s)
|
||||
self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
|
||||
self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
|
||||
self.assertEqual(res[0:-1:-1], s[0::-1])
|
||||
|
||||
import operator
|
||||
self.assertRaises(ValueError, operator.getitem,
|
||||
|
@ -88,8 +88,8 @@ def test_char_ptr(self):
|
|||
|
||||
dll.my_strdup.restype = POINTER(c_byte)
|
||||
res = dll.my_strdup(s)
|
||||
self.failUnlessEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
|
||||
self.failUnlessEqual(res[:len(s):], list(range(ord("a"), ord("z")+1)))
|
||||
self.assertEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
|
||||
self.assertEqual(res[:len(s):], list(range(ord("a"), ord("z")+1)))
|
||||
dll.my_free(res)
|
||||
|
||||
def test_char_ptr_with_free(self):
|
||||
|
@ -109,7 +109,7 @@ def errcheck(result, func, args):
|
|||
dll.my_strdup.errcheck = errcheck
|
||||
try:
|
||||
res = dll.my_strdup(s)
|
||||
self.failUnlessEqual(res, s.decode())
|
||||
self.assertEqual(res, s.decode())
|
||||
finally:
|
||||
del dll.my_strdup.errcheck
|
||||
|
||||
|
@ -118,11 +118,11 @@ def test_char_array(self):
|
|||
s = b"abcdefghijklmnopqrstuvwxyz\0"
|
||||
|
||||
p = (c_char * 27)(*s)
|
||||
self.failUnlessEqual(p[:], s)
|
||||
self.failUnlessEqual(p[::], s)
|
||||
self.failUnlessEqual(p[::-1], s[::-1])
|
||||
self.failUnlessEqual(p[5::-2], s[5::-2])
|
||||
self.failUnlessEqual(p[2:5:-3], s[2:5:-3])
|
||||
self.assertEqual(p[:], s)
|
||||
self.assertEqual(p[::], s)
|
||||
self.assertEqual(p[::-1], s[::-1])
|
||||
self.assertEqual(p[5::-2], s[5::-2])
|
||||
self.assertEqual(p[2:5:-3], s[2:5:-3])
|
||||
|
||||
|
||||
try:
|
||||
|
@ -138,10 +138,10 @@ def test_wchar_ptr(self):
|
|||
dll.my_wcsdup.argtypes = POINTER(c_wchar),
|
||||
dll.my_free.restype = None
|
||||
res = dll.my_wcsdup(s)
|
||||
self.failUnlessEqual(res[:len(s)], s)
|
||||
self.failUnlessEqual(res[:len(s):], s)
|
||||
self.failUnlessEqual(res[len(s)-1:-1:-1], s[::-1])
|
||||
self.failUnlessEqual(res[len(s)-1:5:-7], s[:5:-7])
|
||||
self.assertEqual(res[:len(s)], s)
|
||||
self.assertEqual(res[:len(s):], s)
|
||||
self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
|
||||
self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
|
||||
|
||||
import operator
|
||||
self.assertRaises(TypeError, operator.setitem,
|
||||
|
@ -158,10 +158,10 @@ def test_wchar_ptr(self):
|
|||
return
|
||||
res = dll.my_wcsdup(s)
|
||||
tmpl = list(range(ord("a"), ord("z")+1))
|
||||
self.failUnlessEqual(res[:len(s)-1], tmpl)
|
||||
self.failUnlessEqual(res[:len(s)-1:], tmpl)
|
||||
self.failUnlessEqual(res[len(s)-2:-1:-1], tmpl[::-1])
|
||||
self.failUnlessEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
|
||||
self.assertEqual(res[:len(s)-1], tmpl)
|
||||
self.assertEqual(res[:len(s)-1:], tmpl)
|
||||
self.assertEqual(res[len(s)-2:-1:-1], tmpl[::-1])
|
||||
self.assertEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
|
||||
dll.my_free(res)
|
||||
|
||||
################################################################
|
||||
|
|
|
@ -16,14 +16,14 @@ class X(Structure):
|
|||
self.assertRaises(ValueError, getattr, x.str, "contents")
|
||||
b = c_buffer("Hello, World")
|
||||
from sys import getrefcount as grc
|
||||
self.failUnlessEqual(grc(b), 2)
|
||||
self.assertEqual(grc(b), 2)
|
||||
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 c_buffer() is compatible
|
||||
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")
|
||||
|
||||
|
@ -34,11 +34,11 @@ class X(Structure):
|
|||
|
||||
# c_char_p and Python string is compatible
|
||||
# c_char_p and c_buffer is NOT compatible
|
||||
self.failUnlessEqual(x.str, None)
|
||||
self.assertEqual(x.str, None)
|
||||
x.str = "Hello, World"
|
||||
self.failUnlessEqual(x.str, "Hello, World")
|
||||
self.assertEqual(x.str, "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):
|
||||
|
@ -48,15 +48,15 @@ def test_functions(self):
|
|||
# c_char_p and Python string is compatible
|
||||
# c_char_p and c_buffer are now compatible
|
||||
strchr.argtypes = c_char_p, c_char
|
||||
self.failUnlessEqual(strchr("abcdef", "c"), "cdef")
|
||||
self.failUnlessEqual(strchr(c_buffer("abcdef"), "c"), "cdef")
|
||||
self.assertEqual(strchr("abcdef", "c"), "cdef")
|
||||
self.assertEqual(strchr(c_buffer("abcdef"), "c"), "cdef")
|
||||
|
||||
# POINTER(c_char) and Python string is NOT compatible
|
||||
# POINTER(c_char) and c_buffer() is compatible
|
||||
strchr.argtypes = POINTER(c_char), c_char
|
||||
buf = c_buffer("abcdef")
|
||||
self.failUnlessEqual(strchr(buf, "c"), "cdef")
|
||||
self.failUnlessEqual(strchr("abcdef", "c"), "cdef")
|
||||
self.assertEqual(strchr(buf, "c"), "cdef")
|
||||
self.assertEqual(strchr("abcdef", "c"), "cdef")
|
||||
|
||||
# XXX These calls are dangerous, because the first argument
|
||||
# to strchr is no longer valid after the function returns!
|
||||
|
@ -66,7 +66,7 @@ def test_functions(self):
|
|||
buf = c_buffer("abcdef")
|
||||
r = strchr(buf, "c")
|
||||
x = r[0], r[1], r[2], r[3], r[4]
|
||||
self.failUnlessEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
|
||||
self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
|
||||
del buf
|
||||
# x1 will NOT be the same as x, usually:
|
||||
x1 = r[0], r[1], r[2], r[3], r[4]
|
||||
|
|
|
@ -6,20 +6,20 @@ def test(self):
|
|||
BUF = c_char * 4
|
||||
|
||||
buf = BUF("a", "b", "c")
|
||||
self.failUnlessEqual(buf.value, b"abc")
|
||||
self.failUnlessEqual(buf.raw, b"abc\000")
|
||||
self.assertEqual(buf.value, b"abc")
|
||||
self.assertEqual(buf.raw, b"abc\000")
|
||||
|
||||
buf.value = "ABCD"
|
||||
self.failUnlessEqual(buf.value, b"ABCD")
|
||||
self.failUnlessEqual(buf.raw, b"ABCD")
|
||||
self.assertEqual(buf.value, b"ABCD")
|
||||
self.assertEqual(buf.raw, b"ABCD")
|
||||
|
||||
buf.value = "x"
|
||||
self.failUnlessEqual(buf.value, b"x")
|
||||
self.failUnlessEqual(buf.raw, b"x\000CD")
|
||||
self.assertEqual(buf.value, b"x")
|
||||
self.assertEqual(buf.raw, b"x\000CD")
|
||||
|
||||
buf[1] = "Z"
|
||||
self.failUnlessEqual(buf.value, b"xZCD")
|
||||
self.failUnlessEqual(buf.raw, b"xZCD")
|
||||
self.assertEqual(buf.value, b"xZCD")
|
||||
self.assertEqual(buf.raw, b"xZCD")
|
||||
|
||||
self.assertRaises(ValueError, setattr, buf, "value", "aaaaaaaa")
|
||||
self.assertRaises(TypeError, setattr, buf, "value", 42)
|
||||
|
@ -28,9 +28,9 @@ def test_c_buffer_value(self):
|
|||
buf = c_buffer(32)
|
||||
|
||||
buf.value = b"Hello, World"
|
||||
self.failUnlessEqual(buf.value, b"Hello, World")
|
||||
self.assertEqual(buf.value, b"Hello, World")
|
||||
|
||||
self.failUnlessRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
|
||||
self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
|
||||
self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
|
||||
self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
|
||||
|
||||
|
@ -38,7 +38,7 @@ def test_c_buffer_raw(self):
|
|||
buf = c_buffer(32)
|
||||
|
||||
buf.raw = memoryview(b"Hello, World")
|
||||
self.failUnlessEqual(buf.value, b"Hello, World")
|
||||
self.assertEqual(buf.value, b"Hello, World")
|
||||
self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
|
||||
self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
|
||||
|
||||
|
@ -63,16 +63,16 @@ def test(self):
|
|||
BUF = c_wchar * 4
|
||||
|
||||
buf = BUF("a", "b", "c")
|
||||
self.failUnlessEqual(buf.value, "abc")
|
||||
self.assertEqual(buf.value, "abc")
|
||||
|
||||
buf.value = "ABCD"
|
||||
self.failUnlessEqual(buf.value, "ABCD")
|
||||
self.assertEqual(buf.value, "ABCD")
|
||||
|
||||
buf.value = "x"
|
||||
self.failUnlessEqual(buf.value, "x")
|
||||
self.assertEqual(buf.value, "x")
|
||||
|
||||
buf[1] = "Z"
|
||||
self.failUnlessEqual(buf.value, "xZCD")
|
||||
self.assertEqual(buf.value, "xZCD")
|
||||
|
||||
class StringTestCase(unittest.TestCase):
|
||||
def XX_test_basic_strings(self):
|
||||
|
@ -80,24 +80,24 @@ def XX_test_basic_strings(self):
|
|||
|
||||
# Cannot call len on a c_string any longer
|
||||
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.
|
||||
self.failUnlessEqual(cs.value, "abcdef")
|
||||
self.failUnlessEqual(c_string("abc\000def").value, "abc")
|
||||
self.assertEqual(cs.value, "abcdef")
|
||||
self.assertEqual(c_string("abc\000def").value, "abc")
|
||||
|
||||
# The raw property is the total buffer contents:
|
||||
self.failUnlessEqual(cs.raw, "abcdef\000")
|
||||
self.failUnlessEqual(c_string("abc\000def").raw, "abc\000def\000")
|
||||
self.assertEqual(cs.raw, "abcdef\000")
|
||||
self.assertEqual(c_string("abc\000def").raw, "abc\000def\000")
|
||||
|
||||
# We can change the value:
|
||||
cs.value = "ab"
|
||||
self.failUnlessEqual(cs.value, "ab")
|
||||
self.failUnlessEqual(cs.raw, "ab\000\000\000\000\000")
|
||||
self.assertEqual(cs.value, "ab")
|
||||
self.assertEqual(cs.raw, "ab\000\000\000\000\000")
|
||||
|
||||
cs.raw = "XY"
|
||||
self.failUnlessEqual(cs.value, "XY")
|
||||
self.failUnlessEqual(cs.raw, "XY\000\000\000\000\000")
|
||||
self.assertEqual(cs.value, "XY")
|
||||
self.assertEqual(cs.raw, "XY\000\000\000\000\000")
|
||||
|
||||
self.assertRaises(TypeError, c_string, "123")
|
||||
|
||||
|
@ -108,24 +108,24 @@ def XX_test_sized_strings(self):
|
|||
|
||||
# New in releases later than 0.4.0:
|
||||
# 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, 0)
|
||||
|
||||
# These tests fail, because it is no longer initialized
|
||||
## self.failUnless(c_string(2).value == "")
|
||||
## self.failUnless(c_string(2).raw == "\000\000")
|
||||
self.failUnless(c_string(2).raw[-1] == "\000")
|
||||
self.failUnless(len(c_string(2).raw) == 2)
|
||||
## self.assertTrue(c_string(2).value == "")
|
||||
## self.assertTrue(c_string(2).raw == "\000\000")
|
||||
self.assertTrue(c_string(2).raw[-1] == "\000")
|
||||
self.assertTrue(len(c_string(2).raw) == 2)
|
||||
|
||||
def XX_test_initialized_strings(self):
|
||||
|
||||
self.failUnless(c_string("ab", 4).raw[:2] == "ab")
|
||||
self.failUnless(c_string("ab", 4).raw[:2:] == "ab")
|
||||
self.failUnless(c_string("ab", 4).raw[:2:-1] == "ba")
|
||||
self.failUnless(c_string("ab", 4).raw[:2:2] == "a")
|
||||
self.failUnless(c_string("ab", 4).raw[-1] == "\000")
|
||||
self.failUnless(c_string("ab", 2).raw == "a\000")
|
||||
self.assertTrue(c_string("ab", 4).raw[:2] == "ab")
|
||||
self.assertTrue(c_string("ab", 4).raw[:2:] == "ab")
|
||||
self.assertTrue(c_string("ab", 4).raw[:2:-1] == "ba")
|
||||
self.assertTrue(c_string("ab", 4).raw[:2:2] == "a")
|
||||
self.assertTrue(c_string("ab", 4).raw[-1] == "\000")
|
||||
self.assertTrue(c_string("ab", 2).raw == "a\000")
|
||||
|
||||
def XX_test_toolong(self):
|
||||
cs = c_string("abcdef")
|
||||
|
@ -156,22 +156,22 @@ def X_test_basic_wstrings(self):
|
|||
# XXX This behaviour is about to change:
|
||||
# len returns the size of the internal buffer in bytes.
|
||||
# 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.
|
||||
self.failUnless(cs.value == "abcdef")
|
||||
self.failUnless(c_wstring("abc\000def").value == "abc")
|
||||
self.assertTrue(cs.value == "abcdef")
|
||||
self.assertTrue(c_wstring("abc\000def").value == "abc")
|
||||
|
||||
self.failUnless(c_wstring("abc\000def").value == "abc")
|
||||
self.assertTrue(c_wstring("abc\000def").value == "abc")
|
||||
|
||||
# The raw property is the total buffer contents:
|
||||
self.failUnless(cs.raw == "abcdef\000")
|
||||
self.failUnless(c_wstring("abc\000def").raw == "abc\000def\000")
|
||||
self.assertTrue(cs.raw == "abcdef\000")
|
||||
self.assertTrue(c_wstring("abc\000def").raw == "abc\000def\000")
|
||||
|
||||
# We can change the value:
|
||||
cs.value = "ab"
|
||||
self.failUnless(cs.value == "ab")
|
||||
self.failUnless(cs.raw == "ab\000\000\000\000\000")
|
||||
self.assertTrue(cs.value == "ab")
|
||||
self.assertTrue(cs.raw == "ab\000\000\000\000\000")
|
||||
|
||||
self.assertRaises(TypeError, c_wstring, "123")
|
||||
self.assertRaises(ValueError, c_wstring, 0)
|
||||
|
|
|
@ -15,7 +15,7 @@ class StructFieldsTestCase(unittest.TestCase):
|
|||
def test_1_A(self):
|
||||
class X(Structure):
|
||||
pass
|
||||
self.failUnlessEqual(sizeof(X), 0) # not finalized
|
||||
self.assertEqual(sizeof(X), 0) # not finalized
|
||||
X._fields_ = [] # finalized
|
||||
self.assertRaises(AttributeError, setattr, X, "_fields_", [])
|
||||
|
||||
|
|
|
@ -13,33 +13,33 @@ class Y(X):
|
|||
class Z(X):
|
||||
pass
|
||||
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_int))
|
||||
self.failUnlessEqual(sizeof(Y), sizeof(c_int)*2)
|
||||
self.failUnlessEqual(sizeof(Z), sizeof(c_int))
|
||||
self.failUnlessEqual(X._fields_, [("a", c_int)])
|
||||
self.failUnlessEqual(Y._fields_, [("b", c_int)])
|
||||
self.failUnlessEqual(Z._fields_, [("a", c_int)])
|
||||
self.assertEqual(sizeof(X), sizeof(c_int))
|
||||
self.assertEqual(sizeof(Y), sizeof(c_int)*2)
|
||||
self.assertEqual(sizeof(Z), sizeof(c_int))
|
||||
self.assertEqual(X._fields_, [("a", c_int)])
|
||||
self.assertEqual(Y._fields_, [("b", c_int)])
|
||||
self.assertEqual(Z._fields_, [("a", c_int)])
|
||||
|
||||
def test_subclass_delayed(self):
|
||||
class X(Structure):
|
||||
pass
|
||||
self.failUnlessEqual(sizeof(X), 0)
|
||||
self.assertEqual(sizeof(X), 0)
|
||||
X._fields_ = [("a", c_int)]
|
||||
|
||||
class Y(X):
|
||||
pass
|
||||
self.failUnlessEqual(sizeof(Y), sizeof(X))
|
||||
self.assertEqual(sizeof(Y), sizeof(X))
|
||||
Y._fields_ = [("b", c_int)]
|
||||
|
||||
class Z(X):
|
||||
pass
|
||||
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_int))
|
||||
self.failUnlessEqual(sizeof(Y), sizeof(c_int)*2)
|
||||
self.failUnlessEqual(sizeof(Z), sizeof(c_int))
|
||||
self.failUnlessEqual(X._fields_, [("a", c_int)])
|
||||
self.failUnlessEqual(Y._fields_, [("b", c_int)])
|
||||
self.failUnlessEqual(Z._fields_, [("a", c_int)])
|
||||
self.assertEqual(sizeof(X), sizeof(c_int))
|
||||
self.assertEqual(sizeof(Y), sizeof(c_int)*2)
|
||||
self.assertEqual(sizeof(Z), sizeof(c_int))
|
||||
self.assertEqual(X._fields_, [("a", c_int)])
|
||||
self.assertEqual(Y._fields_, [("b", c_int)])
|
||||
self.assertEqual(Z._fields_, [("a", c_int)])
|
||||
|
||||
class StructureTestCase(unittest.TestCase):
|
||||
formats = {"c": c_char,
|
||||
|
@ -62,7 +62,7 @@ def test_simple_structs(self):
|
|||
class X(Structure):
|
||||
_fields_ = [("x", c_char),
|
||||
("y", tp)]
|
||||
self.failUnlessEqual((sizeof(X), code),
|
||||
self.assertEqual((sizeof(X), code),
|
||||
(calcsize("c%c0%c" % (code, code)), code))
|
||||
|
||||
def test_unions(self):
|
||||
|
@ -70,39 +70,39 @@ def test_unions(self):
|
|||
class X(Union):
|
||||
_fields_ = [("x", c_char),
|
||||
("y", tp)]
|
||||
self.failUnlessEqual((sizeof(X), code),
|
||||
self.assertEqual((sizeof(X), code),
|
||||
(calcsize("%c" % (code)), code))
|
||||
|
||||
def test_struct_alignment(self):
|
||||
class X(Structure):
|
||||
_fields_ = [("x", c_char * 3)]
|
||||
self.failUnlessEqual(alignment(X), calcsize("s"))
|
||||
self.failUnlessEqual(sizeof(X), calcsize("3s"))
|
||||
self.assertEqual(alignment(X), calcsize("s"))
|
||||
self.assertEqual(sizeof(X), calcsize("3s"))
|
||||
|
||||
class Y(Structure):
|
||||
_fields_ = [("x", c_char * 3),
|
||||
("y", c_int)]
|
||||
self.failUnlessEqual(alignment(Y), calcsize("i"))
|
||||
self.failUnlessEqual(sizeof(Y), calcsize("3si"))
|
||||
self.assertEqual(alignment(Y), calcsize("i"))
|
||||
self.assertEqual(sizeof(Y), calcsize("3si"))
|
||||
|
||||
class SI(Structure):
|
||||
_fields_ = [("a", X),
|
||||
("b", Y)]
|
||||
self.failUnlessEqual(alignment(SI), max(alignment(Y), alignment(X)))
|
||||
self.failUnlessEqual(sizeof(SI), calcsize("3s0i 3si 0i"))
|
||||
self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
|
||||
self.assertEqual(sizeof(SI), calcsize("3s0i 3si 0i"))
|
||||
|
||||
class IS(Structure):
|
||||
_fields_ = [("b", Y),
|
||||
("a", X)]
|
||||
|
||||
self.failUnlessEqual(alignment(SI), max(alignment(X), alignment(Y)))
|
||||
self.failUnlessEqual(sizeof(IS), calcsize("3si 3s 0i"))
|
||||
self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
|
||||
self.assertEqual(sizeof(IS), calcsize("3si 3s 0i"))
|
||||
|
||||
class XX(Structure):
|
||||
_fields_ = [("a", X),
|
||||
("b", X)]
|
||||
self.failUnlessEqual(alignment(XX), alignment(X))
|
||||
self.failUnlessEqual(sizeof(XX), calcsize("3s 3s 0s"))
|
||||
self.assertEqual(alignment(XX), alignment(X))
|
||||
self.assertEqual(sizeof(XX), calcsize("3s 3s 0s"))
|
||||
|
||||
def test_emtpy(self):
|
||||
# I had problems with these
|
||||
|
@ -115,15 +115,15 @@ class Y(Union):
|
|||
_fields_ = []
|
||||
|
||||
# Is this really the correct alignment, or should it be 0?
|
||||
self.failUnless(alignment(X) == alignment(Y) == 1)
|
||||
self.failUnless(sizeof(X) == sizeof(Y) == 0)
|
||||
self.assertTrue(alignment(X) == alignment(Y) == 1)
|
||||
self.assertTrue(sizeof(X) == sizeof(Y) == 0)
|
||||
|
||||
class XX(Structure):
|
||||
_fields_ = [("a", X),
|
||||
("b", X)]
|
||||
|
||||
self.failUnlessEqual(alignment(XX), 1)
|
||||
self.failUnlessEqual(sizeof(XX), 0)
|
||||
self.assertEqual(alignment(XX), 1)
|
||||
self.assertEqual(sizeof(XX), 0)
|
||||
|
||||
def test_fields(self):
|
||||
# test the offset and size attributes of Structure/Unoin fields.
|
||||
|
@ -131,11 +131,11 @@ class X(Structure):
|
|||
_fields_ = [("x", c_int),
|
||||
("y", c_char)]
|
||||
|
||||
self.failUnlessEqual(X.x.offset, 0)
|
||||
self.failUnlessEqual(X.x.size, sizeof(c_int))
|
||||
self.assertEqual(X.x.offset, 0)
|
||||
self.assertEqual(X.x.size, sizeof(c_int))
|
||||
|
||||
self.failUnlessEqual(X.y.offset, sizeof(c_int))
|
||||
self.failUnlessEqual(X.y.size, sizeof(c_char))
|
||||
self.assertEqual(X.y.offset, sizeof(c_int))
|
||||
self.assertEqual(X.y.size, sizeof(c_char))
|
||||
|
||||
# readonly
|
||||
self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
|
||||
|
@ -145,11 +145,11 @@ class X(Union):
|
|||
_fields_ = [("x", c_int),
|
||||
("y", c_char)]
|
||||
|
||||
self.failUnlessEqual(X.x.offset, 0)
|
||||
self.failUnlessEqual(X.x.size, sizeof(c_int))
|
||||
self.assertEqual(X.x.offset, 0)
|
||||
self.assertEqual(X.x.size, sizeof(c_int))
|
||||
|
||||
self.failUnlessEqual(X.y.offset, 0)
|
||||
self.failUnlessEqual(X.y.size, sizeof(c_char))
|
||||
self.assertEqual(X.y.offset, 0)
|
||||
self.assertEqual(X.y.size, sizeof(c_char))
|
||||
|
||||
# readonly
|
||||
self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
|
||||
|
@ -164,22 +164,22 @@ class X(Structure):
|
|||
("b", c_longlong)]
|
||||
_pack_ = 1
|
||||
|
||||
self.failUnlessEqual(sizeof(X), 9)
|
||||
self.failUnlessEqual(X.b.offset, 1)
|
||||
self.assertEqual(sizeof(X), 9)
|
||||
self.assertEqual(X.b.offset, 1)
|
||||
|
||||
class X(Structure):
|
||||
_fields_ = [("a", c_byte),
|
||||
("b", c_longlong)]
|
||||
_pack_ = 2
|
||||
self.failUnlessEqual(sizeof(X), 10)
|
||||
self.failUnlessEqual(X.b.offset, 2)
|
||||
self.assertEqual(sizeof(X), 10)
|
||||
self.assertEqual(X.b.offset, 2)
|
||||
|
||||
class X(Structure):
|
||||
_fields_ = [("a", c_byte),
|
||||
("b", c_longlong)]
|
||||
_pack_ = 4
|
||||
self.failUnlessEqual(sizeof(X), 12)
|
||||
self.failUnlessEqual(X.b.offset, 4)
|
||||
self.assertEqual(sizeof(X), 12)
|
||||
self.assertEqual(X.b.offset, 4)
|
||||
|
||||
import struct
|
||||
longlong_size = struct.calcsize("q")
|
||||
|
@ -190,8 +190,8 @@ class X(Structure):
|
|||
("b", c_longlong)]
|
||||
_pack_ = 8
|
||||
|
||||
self.failUnlessEqual(sizeof(X), longlong_align + longlong_size)
|
||||
self.failUnlessEqual(X.b.offset, min(8, longlong_align))
|
||||
self.assertEqual(sizeof(X), longlong_align + longlong_size)
|
||||
self.assertEqual(X.b.offset, min(8, longlong_align))
|
||||
|
||||
|
||||
d = {"_fields_": [("a", "b"),
|
||||
|
@ -209,9 +209,9 @@ class Person(Structure):
|
|||
self.assertRaises(TypeError, Person, "Name", "HI")
|
||||
|
||||
# short enough
|
||||
self.failUnlessEqual(Person("12345", 5).name, "12345")
|
||||
self.assertEqual(Person("12345", 5).name, "12345")
|
||||
# exact fit
|
||||
self.failUnlessEqual(Person("123456", 5).name, "123456")
|
||||
self.assertEqual(Person("123456", 5).name, "123456")
|
||||
# too long
|
||||
self.assertRaises(ValueError, Person, "1234567", 5)
|
||||
|
||||
|
@ -229,10 +229,10 @@ def test_keyword_initializers(self):
|
|||
class POINT(Structure):
|
||||
_fields_ = [("x", c_int), ("y", c_int)]
|
||||
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)
|
||||
self.failUnlessEqual((pt.x, pt.y), (1, 2))
|
||||
self.assertEqual((pt.x, pt.y), (1, 2))
|
||||
|
||||
def test_invalid_field_types(self):
|
||||
class POINT(Structure):
|
||||
|
@ -244,14 +244,14 @@ class SomeInts(Structure):
|
|||
_fields_ = [("a", c_int * 4)]
|
||||
|
||||
# can use tuple to initialize array (but not list!)
|
||||
self.failUnlessEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
|
||||
self.failUnlessEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
|
||||
self.failUnlessEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
|
||||
self.failUnlessEqual(SomeInts((1, 2)).a[::2], [1, 0])
|
||||
self.failUnlessEqual(SomeInts((1, 2)).a[1:5:6], [2])
|
||||
self.failUnlessEqual(SomeInts((1, 2)).a[6:4:-1], [])
|
||||
self.failUnlessEqual(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)).a[:], [1, 2, 0, 0])
|
||||
self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
|
||||
self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
|
||||
self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
|
||||
self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
|
||||
self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
|
||||
self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
|
||||
self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
|
||||
# too long
|
||||
# XXX Should raise ValueError?, not RuntimeError
|
||||
self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
|
||||
|
@ -269,10 +269,10 @@ class Person(Structure):
|
|||
|
||||
p = Person("Someone", ("1234", "5678"), 5)
|
||||
|
||||
self.failUnlessEqual(p.name, "Someone")
|
||||
self.failUnlessEqual(p.phone.areacode, "1234")
|
||||
self.failUnlessEqual(p.phone.number, "5678")
|
||||
self.failUnlessEqual(p.age, 5)
|
||||
self.assertEqual(p.name, "Someone")
|
||||
self.assertEqual(p.phone.areacode, "1234")
|
||||
self.assertEqual(p.phone.number, "5678")
|
||||
self.assertEqual(p.age, 5)
|
||||
|
||||
def test_structures_with_wchar(self):
|
||||
try:
|
||||
|
@ -285,12 +285,12 @@ class PersonW(Structure):
|
|||
("age", c_int)]
|
||||
|
||||
p = PersonW("Someone")
|
||||
self.failUnlessEqual(p.name, "Someone")
|
||||
self.assertEqual(p.name, "Someone")
|
||||
|
||||
self.failUnlessEqual(PersonW("1234567890").name, "1234567890")
|
||||
self.failUnlessEqual(PersonW("12345678901").name, "12345678901")
|
||||
self.assertEqual(PersonW("1234567890").name, "1234567890")
|
||||
self.assertEqual(PersonW("12345678901").name, "12345678901")
|
||||
# exact fit
|
||||
self.failUnlessEqual(PersonW("123456789012").name, "123456789012")
|
||||
self.assertEqual(PersonW("123456789012").name, "123456789012")
|
||||
#too long
|
||||
self.assertRaises(ValueError, PersonW, "1234567890123")
|
||||
|
||||
|
@ -305,18 +305,18 @@ class Person(Structure):
|
|||
("age", c_int)]
|
||||
|
||||
cls, msg = self.get_except(Person, "Someone", (1, 2))
|
||||
self.failUnlessEqual(cls, RuntimeError)
|
||||
self.failUnlessEqual(msg,
|
||||
self.assertEqual(cls, RuntimeError)
|
||||
self.assertEqual(msg,
|
||||
"(Phone) <class 'TypeError'>: "
|
||||
"expected string, int found")
|
||||
|
||||
cls, msg = self.get_except(Person, "Someone", ("a", "b", "c"))
|
||||
self.failUnlessEqual(cls, RuntimeError)
|
||||
self.assertEqual(cls, RuntimeError)
|
||||
if issubclass(Exception, object):
|
||||
self.failUnlessEqual(msg,
|
||||
self.assertEqual(msg,
|
||||
"(Phone) <class 'TypeError'>: too many initializers")
|
||||
else:
|
||||
self.failUnlessEqual(msg, "(Phone) TypeError: too many initializers")
|
||||
self.assertEqual(msg, "(Phone) TypeError: too many initializers")
|
||||
|
||||
|
||||
def get_except(self, func, *args):
|
||||
|
@ -331,7 +331,7 @@ def get_except(self, func, *args):
|
|||
## # same as 'class X(Structure): pass'
|
||||
## # fails, since we need either a _fields_ or a _abstract_ attribute
|
||||
## cls, msg = self.get_except(meta, "X", (Structure,), {})
|
||||
## self.failUnlessEqual((cls, msg),
|
||||
## self.assertEqual((cls, msg),
|
||||
## (AttributeError, "class must define a '_fields_' attribute"))
|
||||
|
||||
def test_abstract_class(self):
|
||||
|
@ -339,15 +339,15 @@ class X(Structure):
|
|||
_abstract_ = "something"
|
||||
# try 'X()'
|
||||
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):
|
||||
## class X(Structure):
|
||||
## _fields_ = []
|
||||
|
||||
self.failUnless("in_dll" in dir(type(Structure)))
|
||||
self.failUnless("from_address" in dir(type(Structure)))
|
||||
self.failUnless("in_dll" in dir(type(Structure)))
|
||||
self.assertTrue("in_dll" in dir(type(Structure)))
|
||||
self.assertTrue("from_address" in dir(type(Structure)))
|
||||
self.assertTrue("in_dll" in dir(type(Structure)))
|
||||
|
||||
class PointerMemberTestCase(unittest.TestCase):
|
||||
|
||||
|
@ -360,7 +360,7 @@ class S(Structure):
|
|||
# We can assign arrays of the correct type
|
||||
s.array = (c_int * 3)(1, 2, 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
|
||||
# also describe the current behaviour.
|
||||
|
@ -371,14 +371,14 @@ class S(Structure):
|
|||
s.array[0] = 42
|
||||
|
||||
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[1] = 42
|
||||
|
||||
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):
|
||||
class S(Structure):
|
||||
|
@ -388,7 +388,7 @@ class S(Structure):
|
|||
s = S()
|
||||
s.x = 12345678
|
||||
s.p = None
|
||||
self.failUnlessEqual(s.x, 12345678)
|
||||
self.assertEqual(s.x, 12345678)
|
||||
|
||||
class TestRecursiveStructure(unittest.TestCase):
|
||||
def test_contains_itself(self):
|
||||
|
@ -398,7 +398,7 @@ class Recursive(Structure):
|
|||
try:
|
||||
Recursive._fields_ = [("next", Recursive)]
|
||||
except AttributeError as details:
|
||||
self.failUnless("Structure or union cannot contain itself" in
|
||||
self.assertTrue("Structure or union cannot contain itself" in
|
||||
str(details))
|
||||
else:
|
||||
self.fail("Structure or union cannot contain itself")
|
||||
|
@ -415,7 +415,7 @@ class Second(Structure):
|
|||
try:
|
||||
Second._fields_ = [("first", First)]
|
||||
except AttributeError as details:
|
||||
self.failUnless("_fields_ is final" in
|
||||
self.assertTrue("_fields_ is final" in
|
||||
str(details))
|
||||
else:
|
||||
self.fail("AttributeError not raised")
|
||||
|
|
|
@ -28,18 +28,18 @@ class TestStructures(unittest.TestCase):
|
|||
def test_native(self):
|
||||
for typ in structures:
|
||||
## print typ.value
|
||||
self.failUnlessEqual(typ.value.offset, 1)
|
||||
self.assertEqual(typ.value.offset, 1)
|
||||
o = typ()
|
||||
o.value = 4
|
||||
self.failUnlessEqual(o.value, 4)
|
||||
self.assertEqual(o.value, 4)
|
||||
|
||||
def test_swapped(self):
|
||||
for typ in byteswapped_structures:
|
||||
## print >> sys.stderr, typ.value
|
||||
self.failUnlessEqual(typ.value.offset, 1)
|
||||
self.assertEqual(typ.value.offset, 1)
|
||||
o = typ()
|
||||
o.value = 4
|
||||
self.failUnlessEqual(o.value, 4)
|
||||
self.assertEqual(o.value, 4)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
|
@ -22,55 +22,55 @@ def tearDown(self):
|
|||
def test_ascii_strict(self):
|
||||
ctypes.set_conversion_mode("ascii", "strict")
|
||||
# no conversions take place with unicode arguments
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessEqual(wcslen("ab\u2070"), 3)
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertEqual(wcslen("ab\u2070"), 3)
|
||||
# string args are converted
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
|
||||
|
||||
def test_ascii_replace(self):
|
||||
ctypes.set_conversion_mode("ascii", "replace")
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessEqual(wcslen("ab\u2070"), 3)
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessEqual(wcslen("ab\xe4"), 3)
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertEqual(wcslen("ab\u2070"), 3)
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertEqual(wcslen("ab\xe4"), 3)
|
||||
|
||||
def test_ascii_ignore(self):
|
||||
ctypes.set_conversion_mode("ascii", "ignore")
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessEqual(wcslen("ab\u2070"), 3)
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertEqual(wcslen("ab\u2070"), 3)
|
||||
# ignore error mode skips non-ascii characters
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessEqual(wcslen(b"\xe4\xf6\xfc\xdf"), 0)
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertEqual(wcslen(b"\xe4\xf6\xfc\xdf"), 0)
|
||||
|
||||
def test_latin1_strict(self):
|
||||
ctypes.set_conversion_mode("latin-1", "strict")
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessEqual(wcslen("ab\u2070"), 3)
|
||||
self.failUnlessEqual(wcslen("abc"), 3)
|
||||
self.failUnlessEqual(wcslen("\xe4\xf6\xfc\xdf"), 4)
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertEqual(wcslen("ab\u2070"), 3)
|
||||
self.assertEqual(wcslen("abc"), 3)
|
||||
self.assertEqual(wcslen("\xe4\xf6\xfc\xdf"), 4)
|
||||
|
||||
def test_buffers(self):
|
||||
ctypes.set_conversion_mode("ascii", "strict")
|
||||
buf = ctypes.create_unicode_buffer("abc")
|
||||
self.failUnlessEqual(len(buf), 3+1)
|
||||
self.assertEqual(len(buf), 3+1)
|
||||
|
||||
ctypes.set_conversion_mode("ascii", "replace")
|
||||
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
|
||||
self.failUnlessEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0")
|
||||
self.failUnlessEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0")
|
||||
self.failUnlessEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba")
|
||||
self.failUnlessEqual(buf[::2], "a\uFFFD\uFFFD")
|
||||
self.failUnlessEqual(buf[6:5:-1], "")
|
||||
self.assertEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0")
|
||||
self.assertEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0")
|
||||
self.assertEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba")
|
||||
self.assertEqual(buf[::2], "a\uFFFD\uFFFD")
|
||||
self.assertEqual(buf[6:5:-1], "")
|
||||
|
||||
ctypes.set_conversion_mode("ascii", "ignore")
|
||||
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
|
||||
# is that correct? not sure. But with 'ignore', you get what you pay for..
|
||||
self.failUnlessEqual(buf[:], "ab\0\0\0\0")
|
||||
self.failUnlessEqual(buf[::], "ab\0\0\0\0")
|
||||
self.failUnlessEqual(buf[::-1], "\0\0\0\0ba")
|
||||
self.failUnlessEqual(buf[::2], "a\0\0")
|
||||
self.failUnlessEqual(buf[6:5:-1], "")
|
||||
self.assertEqual(buf[:], "ab\0\0\0\0")
|
||||
self.assertEqual(buf[::], "ab\0\0\0\0")
|
||||
self.assertEqual(buf[::-1], "\0\0\0\0ba")
|
||||
self.assertEqual(buf[::2], "a\0\0")
|
||||
self.assertEqual(buf[6:5:-1], "")
|
||||
|
||||
import _ctypes_test
|
||||
func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
|
||||
|
@ -88,41 +88,41 @@ def tearDown(self):
|
|||
|
||||
def test_ascii_replace(self):
|
||||
ctypes.set_conversion_mode("ascii", "strict")
|
||||
self.failUnlessEqual(func("abc"), "abc")
|
||||
self.failUnlessEqual(func("abc"), "abc")
|
||||
self.assertEqual(func("abc"), "abc")
|
||||
self.assertEqual(func("abc"), "abc")
|
||||
self.assertRaises(ctypes.ArgumentError, func, "ab\xe4")
|
||||
|
||||
def test_ascii_ignore(self):
|
||||
ctypes.set_conversion_mode("ascii", "ignore")
|
||||
self.failUnlessEqual(func("abc"), "abc")
|
||||
self.failUnlessEqual(func("abc"), "abc")
|
||||
self.failUnlessEqual(func("\xe4\xf6\xfc\xdf"), "")
|
||||
self.assertEqual(func("abc"), "abc")
|
||||
self.assertEqual(func("abc"), "abc")
|
||||
self.assertEqual(func("\xe4\xf6\xfc\xdf"), "")
|
||||
|
||||
def test_ascii_replace(self):
|
||||
ctypes.set_conversion_mode("ascii", "replace")
|
||||
self.failUnlessEqual(func("abc"), "abc")
|
||||
self.failUnlessEqual(func("abc"), "abc")
|
||||
self.failUnlessEqual(func("\xe4\xf6\xfc\xdf"), "????")
|
||||
self.assertEqual(func("abc"), "abc")
|
||||
self.assertEqual(func("abc"), "abc")
|
||||
self.assertEqual(func("\xe4\xf6\xfc\xdf"), "????")
|
||||
|
||||
def test_buffers(self):
|
||||
ctypes.set_conversion_mode("ascii", "strict")
|
||||
buf = ctypes.create_string_buffer("abc")
|
||||
self.failUnlessEqual(len(buf), 3+1)
|
||||
self.assertEqual(len(buf), 3+1)
|
||||
|
||||
ctypes.set_conversion_mode("ascii", "replace")
|
||||
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
|
||||
self.failUnlessEqual(buf[:], b"ab???\0")
|
||||
self.failUnlessEqual(buf[::], b"ab???\0")
|
||||
self.failUnlessEqual(buf[::-1], b"\0???ba")
|
||||
self.failUnlessEqual(buf[::2], b"a??")
|
||||
self.failUnlessEqual(buf[6:5:-1], b"")
|
||||
self.assertEqual(buf[:], b"ab???\0")
|
||||
self.assertEqual(buf[::], b"ab???\0")
|
||||
self.assertEqual(buf[::-1], b"\0???ba")
|
||||
self.assertEqual(buf[::2], b"a??")
|
||||
self.assertEqual(buf[6:5:-1], b"")
|
||||
|
||||
ctypes.set_conversion_mode("ascii", "ignore")
|
||||
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
|
||||
# is that correct? not sure. But with 'ignore', you get what you pay for..
|
||||
self.failUnlessEqual(buf[:], b"ab\0\0\0\0")
|
||||
self.failUnlessEqual(buf[::], b"ab\0\0\0\0")
|
||||
self.failUnlessEqual(buf[::-1], b"\0\0\0\0ba")
|
||||
self.assertEqual(buf[:], b"ab\0\0\0\0")
|
||||
self.assertEqual(buf[::], b"ab\0\0\0\0")
|
||||
self.assertEqual(buf[::-1], b"\0\0\0\0ba")
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
|
@ -15,13 +15,13 @@ def test_an_integer(self):
|
|||
ctdll = CDLL(_ctypes_test.__file__)
|
||||
an_integer = c_int.in_dll(ctdll, "an_integer")
|
||||
x = an_integer.value
|
||||
self.failUnlessEqual(x, ctdll.get_an_integer())
|
||||
self.assertEqual(x, ctdll.get_an_integer())
|
||||
an_integer.value *= 2
|
||||
self.failUnlessEqual(x*2, ctdll.get_an_integer())
|
||||
self.assertEqual(x*2, ctdll.get_an_integer())
|
||||
# To avoid test failures when this test is repeated several
|
||||
# times the original value must be restored
|
||||
an_integer.value = x
|
||||
self.failUnlessEqual(x, ctdll.get_an_integer())
|
||||
self.assertEqual(x, ctdll.get_an_integer())
|
||||
|
||||
def test_undefined(self):
|
||||
ctdll = CDLL(_ctypes_test.__file__)
|
||||
|
@ -40,11 +40,11 @@ def test_optimizeflag(self):
|
|||
# docstrings are also removed in the latter case.
|
||||
opt = c_int.in_dll(pydll, "Py_OptimizeFlag").value
|
||||
if __debug__:
|
||||
self.failUnlessEqual(opt, 0)
|
||||
self.assertEqual(opt, 0)
|
||||
elif ValuesTestCase.__doc__ is not None:
|
||||
self.failUnlessEqual(opt, 1)
|
||||
self.assertEqual(opt, 1)
|
||||
else:
|
||||
self.failUnlessEqual(opt, 2)
|
||||
self.assertEqual(opt, 2)
|
||||
|
||||
def test_frozentable(self):
|
||||
# Python exports a PyImport_FrozenModules symbol. This is a
|
||||
|
@ -76,7 +76,7 @@ class struct_frozen(Structure):
|
|||
expected = [("__hello__", 104), ("__phello__", -104), ("__phello__.spam", 104)]
|
||||
else:
|
||||
expected = [("__hello__", 100), ("__phello__", -100), ("__phello__.spam", 100)]
|
||||
self.failUnlessEqual(items, expected)
|
||||
self.assertEqual(items, expected)
|
||||
|
||||
from ctypes import _pointer_type_cache
|
||||
del _pointer_type_cache[struct_frozen]
|
||||
|
|
|
@ -7,44 +7,44 @@ class X(Structure):
|
|||
_fields_ = [("item", c_int),
|
||||
("array", c_int * 1)]
|
||||
|
||||
self.failUnlessEqual(sizeof(X), sizeof(c_int) * 2)
|
||||
self.assertEqual(sizeof(X), sizeof(c_int) * 2)
|
||||
x = X()
|
||||
x.item = 42
|
||||
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
|
||||
new_size = sizeof(X) + sizeof(c_int) * 1
|
||||
resize(x, new_size)
|
||||
self.failUnlessEqual(sizeof(x), new_size)
|
||||
self.failUnlessEqual((x.item, x.array[0]), (42, 100))
|
||||
self.assertEqual(sizeof(x), new_size)
|
||||
self.assertEqual((x.item, x.array[0]), (42, 100))
|
||||
|
||||
# make room for 10 additional items
|
||||
new_size = sizeof(X) + sizeof(c_int) * 9
|
||||
resize(x, new_size)
|
||||
self.failUnlessEqual(sizeof(x), new_size)
|
||||
self.failUnlessEqual((x.item, x.array[0]), (42, 100))
|
||||
self.assertEqual(sizeof(x), new_size)
|
||||
self.assertEqual((x.item, x.array[0]), (42, 100))
|
||||
|
||||
# make room for one additional item
|
||||
new_size = sizeof(X) + sizeof(c_int) * 1
|
||||
resize(x, new_size)
|
||||
self.failUnlessEqual(sizeof(x), new_size)
|
||||
self.failUnlessEqual((x.item, x.array[0]), (42, 100))
|
||||
self.assertEqual(sizeof(x), new_size)
|
||||
self.assertEqual((x.item, x.array[0]), (42, 100))
|
||||
|
||||
def test_array_invalid_length(self):
|
||||
# cannot create arrays with non-positive size
|
||||
self.failUnlessRaises(ValueError, lambda: c_int * -1)
|
||||
self.failUnlessRaises(ValueError, lambda: c_int * -3)
|
||||
self.assertRaises(ValueError, lambda: c_int * -1)
|
||||
self.assertRaises(ValueError, lambda: c_int * -3)
|
||||
|
||||
def test_zerosized_array(self):
|
||||
array = (c_int * 0)()
|
||||
# accessing elements of zero-sized arrays raise IndexError
|
||||
self.failUnlessRaises(IndexError, array.__setitem__, 0, None)
|
||||
self.failUnlessRaises(IndexError, array.__getitem__, 0)
|
||||
self.failUnlessRaises(IndexError, array.__setitem__, 1, None)
|
||||
self.failUnlessRaises(IndexError, array.__getitem__, 1)
|
||||
self.failUnlessRaises(IndexError, array.__setitem__, -1, None)
|
||||
self.failUnlessRaises(IndexError, array.__getitem__, -1)
|
||||
self.assertRaises(IndexError, array.__setitem__, 0, None)
|
||||
self.assertRaises(IndexError, array.__getitem__, 0)
|
||||
self.assertRaises(IndexError, array.__setitem__, 1, None)
|
||||
self.assertRaises(IndexError, array.__getitem__, 1)
|
||||
self.assertRaises(IndexError, array.__setitem__, -1, None)
|
||||
self.assertRaises(IndexError, array.__getitem__, -1)
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
@ -18,7 +18,7 @@ def test_callconv_1(self):
|
|||
self.assertRaises(ValueError, IsWindow)
|
||||
|
||||
# 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)
|
||||
self.assertRaises(ValueError, IsWindow, 0, 0, 0)
|
||||
|
@ -49,13 +49,13 @@ def test_noargs(self):
|
|||
class TestWintypes(unittest.TestCase):
|
||||
def test_HWND(self):
|
||||
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):
|
||||
from ctypes import wintypes
|
||||
self.failUnlessEqual(sizeof(wintypes.WPARAM),
|
||||
self.assertEqual(sizeof(wintypes.WPARAM),
|
||||
sizeof(c_void_p))
|
||||
self.failUnlessEqual(sizeof(wintypes.LPARAM),
|
||||
self.assertEqual(sizeof(wintypes.LPARAM),
|
||||
sizeof(c_void_p))
|
||||
|
||||
def test_COMError(self):
|
||||
|
@ -84,7 +84,7 @@ class RECT(Structure):
|
|||
|
||||
pt = POINT(10, 10)
|
||||
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__':
|
||||
unittest.main()
|
||||
|
|
|
@ -47,7 +47,7 @@ def test_make_tarball(self):
|
|||
|
||||
# check if the compressed tarball was created
|
||||
tarball = base_name + '.tar.gz'
|
||||
self.assert_(os.path.exists(tarball))
|
||||
self.assertTrue(os.path.exists(tarball))
|
||||
|
||||
# trying an uncompressed one
|
||||
base_name = os.path.join(tmpdir2, 'archive')
|
||||
|
@ -58,7 +58,7 @@ def test_make_tarball(self):
|
|||
finally:
|
||||
os.chdir(old_dir)
|
||||
tarball = base_name + '.tar'
|
||||
self.assert_(os.path.exists(tarball))
|
||||
self.assertTrue(os.path.exists(tarball))
|
||||
|
||||
def _tarinfo(self, path):
|
||||
tar = tarfile.open(path)
|
||||
|
@ -96,7 +96,7 @@ def test_tarfile_vs_tar(self):
|
|||
|
||||
# check if the compressed tarball was created
|
||||
tarball = base_name + '.tar.gz'
|
||||
self.assert_(os.path.exists(tarball))
|
||||
self.assertTrue(os.path.exists(tarball))
|
||||
|
||||
# now create another tarball using `tar`
|
||||
tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
|
||||
|
@ -110,7 +110,7 @@ def test_tarfile_vs_tar(self):
|
|||
finally:
|
||||
os.chdir(old_dir)
|
||||
|
||||
self.assert_(os.path.exists(tarball2))
|
||||
self.assertTrue(os.path.exists(tarball2))
|
||||
# let's compare both tarballs
|
||||
self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2))
|
||||
|
||||
|
@ -123,7 +123,7 @@ def test_tarfile_vs_tar(self):
|
|||
finally:
|
||||
os.chdir(old_dir)
|
||||
tarball = base_name + '.tar'
|
||||
self.assert_(os.path.exists(tarball))
|
||||
self.assertTrue(os.path.exists(tarball))
|
||||
|
||||
# now for a dry_run
|
||||
base_name = os.path.join(tmpdir2, 'archive')
|
||||
|
@ -134,7 +134,7 @@ def test_tarfile_vs_tar(self):
|
|||
finally:
|
||||
os.chdir(old_dir)
|
||||
tarball = base_name + '.tar'
|
||||
self.assert_(os.path.exists(tarball))
|
||||
self.assertTrue(os.path.exists(tarball))
|
||||
|
||||
@unittest.skipUnless(find_executable('compress'),
|
||||
'The compress program is required')
|
||||
|
@ -151,7 +151,7 @@ def test_compress_deprecated(self):
|
|||
finally:
|
||||
os.chdir(old_dir)
|
||||
tarball = base_name + '.tar.Z'
|
||||
self.assert_(os.path.exists(tarball))
|
||||
self.assertTrue(os.path.exists(tarball))
|
||||
self.assertEquals(len(w.warnings), 1)
|
||||
|
||||
# same test with dry_run
|
||||
|
@ -165,7 +165,7 @@ def test_compress_deprecated(self):
|
|||
dry_run=True)
|
||||
finally:
|
||||
os.chdir(old_dir)
|
||||
self.assert_(not os.path.exists(tarball))
|
||||
self.assertTrue(not os.path.exists(tarball))
|
||||
self.assertEquals(len(w.warnings), 1)
|
||||
|
||||
@unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
|
||||
|
|
|
@ -74,7 +74,7 @@ def test_quiet(self):
|
|||
cmd.run()
|
||||
|
||||
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):
|
||||
|
||||
|
@ -114,7 +114,7 @@ def test_no_optimize_flag(self):
|
|||
cmd.run()
|
||||
|
||||
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'))
|
||||
|
||||
def test_suite():
|
||||
|
|
|
@ -21,7 +21,7 @@ def test_get_exe_bytes(self):
|
|||
# and make sure it finds it and returns its content
|
||||
# no matter what platform we have
|
||||
exe_file = cmd.get_exe_bytes()
|
||||
self.assert_(len(exe_file) > 10)
|
||||
self.assertTrue(len(exe_file) > 10)
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(BuildWinInstTestCase)
|
||||
|
|
|
@ -135,7 +135,7 @@ def test_run(self):
|
|||
cmd.run()
|
||||
|
||||
# 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():
|
||||
return unittest.makeSuite(BuildCLibTestCase)
|
||||
|
|
|
@ -74,15 +74,15 @@ def test_build_ext(self):
|
|||
import xx
|
||||
|
||||
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(13,15), 28)
|
||||
self.assertEquals(xx.new().demo(), None)
|
||||
doc = 'This is a template module just for instruction.'
|
||||
self.assertEquals(xx.__doc__, doc)
|
||||
self.assert_(isinstance(xx.Null(), xx.Null))
|
||||
self.assert_(isinstance(xx.Str(), xx.Str))
|
||||
self.assertTrue(isinstance(xx.Null(), xx.Null))
|
||||
self.assertTrue(isinstance(xx.Str(), xx.Str))
|
||||
|
||||
def tearDown(self):
|
||||
# Get everything back to normal
|
||||
|
@ -114,7 +114,7 @@ def test_solaris_enable_shared(self):
|
|||
_config_vars['Py_ENABLE_SHARED'] = old_var
|
||||
|
||||
# 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):
|
||||
# site.USER_SITE was introduced in 2.6
|
||||
|
@ -128,7 +128,7 @@ def test_user_site(self):
|
|||
# making sure the user option is there
|
||||
options = [name for name, short, lable in
|
||||
cmd.user_options]
|
||||
self.assert_('user' in options)
|
||||
self.assertTrue('user' in options)
|
||||
|
||||
# setting a value
|
||||
cmd.user = 1
|
||||
|
@ -144,9 +144,9 @@ def test_user_site(self):
|
|||
|
||||
# see if include_dirs and library_dirs
|
||||
# were set
|
||||
self.assert_(lib in cmd.library_dirs)
|
||||
self.assert_(lib in cmd.rpath)
|
||||
self.assert_(incl in cmd.include_dirs)
|
||||
self.assertTrue(lib in cmd.library_dirs)
|
||||
self.assertTrue(lib in cmd.rpath)
|
||||
self.assertTrue(incl in cmd.include_dirs)
|
||||
|
||||
def test_optional_extension(self):
|
||||
|
||||
|
@ -175,10 +175,10 @@ def test_finalize_options(self):
|
|||
|
||||
from distutils import sysconfig
|
||||
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)
|
||||
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
|
||||
# if it's a string
|
||||
|
@ -192,7 +192,7 @@ def test_finalize_options(self):
|
|||
cmd = build_ext(dist)
|
||||
cmd.library_dirs = 'my_lib_dir'
|
||||
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
|
||||
# if it's a list of os.pathsep's paths
|
||||
|
@ -257,13 +257,13 @@ def test_check_extensions_list(self):
|
|||
'some': 'bar'})]
|
||||
cmd.check_extensions_list(exts)
|
||||
ext = exts[0]
|
||||
self.assert_(isinstance(ext, Extension))
|
||||
self.assertTrue(isinstance(ext, Extension))
|
||||
|
||||
# check_extensions_list adds in ext the values passed
|
||||
# when they are in ('include_dirs', 'library_dirs', 'libraries'
|
||||
# 'extra_objects', 'extra_compile_args', 'extra_link_args')
|
||||
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
|
||||
exts = [('foo.bar', {'sources': [''], 'libraries': 'foo',
|
||||
|
@ -321,7 +321,7 @@ def test_get_outputs(self):
|
|||
so_file = cmd.get_outputs()[0]
|
||||
finally:
|
||||
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],
|
||||
sysconfig.get_config_var('SO'))
|
||||
so_dir = os.path.dirname(so_file)
|
||||
|
@ -330,7 +330,7 @@ def test_get_outputs(self):
|
|||
cmd.inplace = 0
|
||||
cmd.run()
|
||||
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],
|
||||
sysconfig.get_config_var('SO'))
|
||||
so_dir = os.path.dirname(so_file)
|
||||
|
|
|
@ -52,9 +52,9 @@ def test_package_data(self):
|
|||
self.assertEqual(len(cmd.get_outputs()), 3)
|
||||
pkgdest = os.path.join(destination, "pkg")
|
||||
files = os.listdir(pkgdest)
|
||||
self.assert_("__init__.py" in files)
|
||||
self.assert_("__init__.pyc" in files)
|
||||
self.assert_("README.txt" in files)
|
||||
self.assertTrue("__init__.py" in files)
|
||||
self.assertTrue("__init__.pyc" in files)
|
||||
self.assertTrue("README.txt" in files)
|
||||
|
||||
def test_empty_package_dir (self):
|
||||
# See SF 1668596/1720897.
|
||||
|
|
|
@ -16,12 +16,12 @@ class BuildScriptsTestCase(support.TempdirManager,
|
|||
|
||||
def test_default_settings(self):
|
||||
cmd = self.get_build_scripts_cmd("/foo/bar", [])
|
||||
self.assert_(not cmd.force)
|
||||
self.assert_(cmd.build_dir is None)
|
||||
self.assertTrue(not cmd.force)
|
||||
self.assertTrue(cmd.build_dir is None)
|
||||
|
||||
cmd.finalize_options()
|
||||
|
||||
self.assert_(cmd.force)
|
||||
self.assertTrue(cmd.force)
|
||||
self.assertEqual(cmd.build_dir, "/foo/bar")
|
||||
|
||||
def test_build(self):
|
||||
|
@ -37,7 +37,7 @@ def test_build(self):
|
|||
|
||||
built = os.listdir(target)
|
||||
for name in expected:
|
||||
self.assert_(name in built)
|
||||
self.assertTrue(name in built)
|
||||
|
||||
def get_build_scripts_cmd(self, target, scripts):
|
||||
import sys
|
||||
|
@ -100,7 +100,7 @@ def test_version_int(self):
|
|||
|
||||
built = os.listdir(target)
|
||||
for name in expected:
|
||||
self.assert_(name in built)
|
||||
self.assertTrue(name in built)
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(BuildScriptsTestCase)
|
||||
|
|
|
@ -35,7 +35,7 @@ def test_simple_run(self):
|
|||
|
||||
# make sure the files where removed
|
||||
for name, path in dirs:
|
||||
self.assert_(not os.path.exists(path),
|
||||
self.assertTrue(not os.path.exists(path),
|
||||
'%s was not removed' % path)
|
||||
|
||||
# let's run the command again (should spit warnings but suceed)
|
||||
|
|
|
@ -70,7 +70,7 @@ def test_ensure_string(self):
|
|||
|
||||
cmd.option2 = None
|
||||
cmd.ensure_string('option2', 'xxx')
|
||||
self.assert_(hasattr(cmd, 'option2'))
|
||||
self.assertTrue(hasattr(cmd, 'option2'))
|
||||
|
||||
cmd.option3 = 1
|
||||
self.assertRaises(DistutilsOptionError, cmd.ensure_string, 'option3')
|
||||
|
|
|
@ -102,9 +102,9 @@ def test_server_registration(self):
|
|||
def test_server_empty_registration(self):
|
||||
cmd = self._cmd(self.dist)
|
||||
rc = cmd._get_rc_file()
|
||||
self.assert_(not os.path.exists(rc))
|
||||
self.assertTrue(not os.path.exists(rc))
|
||||
cmd._store_pypirc('tarek', 'xxx')
|
||||
self.assert_(os.path.exists(rc))
|
||||
self.assertTrue(os.path.exists(rc))
|
||||
content = open(rc).read()
|
||||
self.assertEquals(content, WANTED)
|
||||
|
||||
|
|
|
@ -73,14 +73,14 @@ def test_clean(self):
|
|||
self.write_file(f2, 'xxx')
|
||||
|
||||
for f in (f1, f2):
|
||||
self.assert_(os.path.exists(f))
|
||||
self.assertTrue(os.path.exists(f))
|
||||
|
||||
pkg_dir, dist = self.create_dist()
|
||||
cmd = config(dist)
|
||||
cmd._clean(f1, f2)
|
||||
|
||||
for f in (f1, f2):
|
||||
self.assert_(not os.path.exists(f))
|
||||
self.assertTrue(not os.path.exists(f))
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(ConfigTestCase)
|
||||
|
|
|
@ -72,7 +72,7 @@ def test_command_packages_cmdline(self):
|
|||
self.assertEqual(d.get_command_packages(),
|
||||
["distutils.command", "foo.bar", "distutils.tests"])
|
||||
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")
|
||||
|
||||
def test_command_packages_configfile(self):
|
||||
|
@ -175,10 +175,10 @@ def test_simple_metadata(self):
|
|||
"version": "1.0"}
|
||||
dist = Distribution(attrs)
|
||||
meta = self.format_metadata(dist)
|
||||
self.assert_("Metadata-Version: 1.0" in meta)
|
||||
self.assert_("provides:" not in meta.lower())
|
||||
self.assert_("requires:" not in meta.lower())
|
||||
self.assert_("obsoletes:" not in meta.lower())
|
||||
self.assertTrue("Metadata-Version: 1.0" in meta)
|
||||
self.assertTrue("provides:" not in meta.lower())
|
||||
self.assertTrue("requires:" not in meta.lower())
|
||||
self.assertTrue("obsoletes:" not in meta.lower())
|
||||
|
||||
def test_provides(self):
|
||||
attrs = {"name": "package",
|
||||
|
@ -190,9 +190,9 @@ def test_provides(self):
|
|||
self.assertEqual(dist.get_provides(),
|
||||
["package", "package.sub"])
|
||||
meta = self.format_metadata(dist)
|
||||
self.assert_("Metadata-Version: 1.1" in meta)
|
||||
self.assert_("requires:" not in meta.lower())
|
||||
self.assert_("obsoletes:" not in meta.lower())
|
||||
self.assertTrue("Metadata-Version: 1.1" in meta)
|
||||
self.assertTrue("requires:" not in meta.lower())
|
||||
self.assertTrue("obsoletes:" not in meta.lower())
|
||||
|
||||
def test_provides_illegal(self):
|
||||
self.assertRaises(ValueError, Distribution,
|
||||
|
@ -210,11 +210,11 @@ def test_requires(self):
|
|||
self.assertEqual(dist.get_requires(),
|
||||
["other", "another (==1.0)"])
|
||||
meta = self.format_metadata(dist)
|
||||
self.assert_("Metadata-Version: 1.1" in meta)
|
||||
self.assert_("provides:" not in meta.lower())
|
||||
self.assert_("Requires: other" in meta)
|
||||
self.assert_("Requires: another (==1.0)" in meta)
|
||||
self.assert_("obsoletes:" not in meta.lower())
|
||||
self.assertTrue("Metadata-Version: 1.1" in meta)
|
||||
self.assertTrue("provides:" not in meta.lower())
|
||||
self.assertTrue("Requires: other" in meta)
|
||||
self.assertTrue("Requires: another (==1.0)" in meta)
|
||||
self.assertTrue("obsoletes:" not in meta.lower())
|
||||
|
||||
def test_requires_illegal(self):
|
||||
self.assertRaises(ValueError, Distribution,
|
||||
|
@ -232,11 +232,11 @@ def test_obsoletes(self):
|
|||
self.assertEqual(dist.get_obsoletes(),
|
||||
["other", "another (<1.0)"])
|
||||
meta = self.format_metadata(dist)
|
||||
self.assert_("Metadata-Version: 1.1" in meta)
|
||||
self.assert_("provides:" not in meta.lower())
|
||||
self.assert_("requires:" not in meta.lower())
|
||||
self.assert_("Obsoletes: other" in meta)
|
||||
self.assert_("Obsoletes: another (<1.0)" in meta)
|
||||
self.assertTrue("Metadata-Version: 1.1" in meta)
|
||||
self.assertTrue("provides:" not in meta.lower())
|
||||
self.assertTrue("requires:" not in meta.lower())
|
||||
self.assertTrue("Obsoletes: other" in meta)
|
||||
self.assertTrue("Obsoletes: another (<1.0)" in meta)
|
||||
|
||||
def test_obsoletes_illegal(self):
|
||||
self.assertRaises(ValueError, Distribution,
|
||||
|
@ -270,14 +270,14 @@ def test_custom_pydistutils(self):
|
|||
if sys.platform in ('linux', 'darwin'):
|
||||
self.environ['HOME'] = temp_dir
|
||||
files = dist.find_config_files()
|
||||
self.assert_(user_filename in files)
|
||||
self.assertTrue(user_filename in files)
|
||||
|
||||
# win32-style
|
||||
if sys.platform == 'win32':
|
||||
# home drive should be found
|
||||
self.environ['HOME'] = temp_dir
|
||||
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))
|
||||
finally:
|
||||
os.remove(user_filename)
|
||||
|
@ -303,7 +303,7 @@ def test_show_help(self):
|
|||
|
||||
output = [line for line in s.getvalue().split('\n')
|
||||
if line.strip() != '']
|
||||
self.assert_(len(output) > 0)
|
||||
self.assertTrue(len(output) > 0)
|
||||
|
||||
def test_suite():
|
||||
suite = unittest.TestSuite()
|
||||
|
|
|
@ -88,7 +88,7 @@ def _expanduser(path):
|
|||
|
||||
def _test_user_site(self):
|
||||
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'})
|
||||
cmd = install(dist)
|
||||
|
@ -96,24 +96,24 @@ def _test_user_site(self):
|
|||
# making sure the user option is there
|
||||
options = [name for name, short, lable in
|
||||
cmd.user_options]
|
||||
self.assert_('user' in options)
|
||||
self.assertTrue('user' in options)
|
||||
|
||||
# setting a value
|
||||
cmd.user = 1
|
||||
|
||||
# user base and site shouldn't be created yet
|
||||
self.assert_(not os.path.exists(self.user_base))
|
||||
self.assert_(not os.path.exists(self.user_site))
|
||||
self.assertTrue(not os.path.exists(self.user_base))
|
||||
self.assertTrue(not os.path.exists(self.user_site))
|
||||
|
||||
# let's run finalize
|
||||
cmd.ensure_finalized()
|
||||
|
||||
# now they should
|
||||
self.assert_(os.path.exists(self.user_base))
|
||||
self.assert_(os.path.exists(self.user_site))
|
||||
self.assertTrue(os.path.exists(self.user_base))
|
||||
self.assertTrue(os.path.exists(self.user_site))
|
||||
|
||||
self.assert_('userbase' in cmd.config_vars)
|
||||
self.assert_('usersite' in cmd.config_vars)
|
||||
self.assertTrue('userbase' in cmd.config_vars)
|
||||
self.assertTrue('usersite' in cmd.config_vars)
|
||||
|
||||
def test_handle_extra_path(self):
|
||||
dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})
|
||||
|
|
|
@ -35,9 +35,9 @@ def test_simple_run(self):
|
|||
# let's check the result
|
||||
self.assertEquals(len(cmd.get_outputs()), 2)
|
||||
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]
|
||||
self.assert_(os.path.exists(os.path.join(inst, rone)))
|
||||
self.assertTrue(os.path.exists(os.path.join(inst, rone)))
|
||||
cmd.outfiles = []
|
||||
|
||||
# let's try with warn_dir one
|
||||
|
@ -47,8 +47,8 @@ def test_simple_run(self):
|
|||
|
||||
# let's check the result
|
||||
self.assertEquals(len(cmd.get_outputs()), 2)
|
||||
self.assert_(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(inst2, rtwo)))
|
||||
self.assertTrue(os.path.exists(os.path.join(inst, rone)))
|
||||
cmd.outfiles = []
|
||||
|
||||
# now using root and empty dir
|
||||
|
@ -65,8 +65,8 @@ def test_simple_run(self):
|
|||
|
||||
# let's check the result
|
||||
self.assertEquals(len(cmd.get_outputs()), 4)
|
||||
self.assert_(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(inst2, rtwo)))
|
||||
self.assertTrue(os.path.exists(os.path.join(inst, rone)))
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(InstallDataTestCase)
|
||||
|
|
|
@ -39,8 +39,8 @@ def test_byte_compile(self):
|
|||
f = os.path.join(pkg_dir, 'foo.py')
|
||||
self.write_file(f, '# python file')
|
||||
cmd.byte_compile([f])
|
||||
self.assert_(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.pyc')))
|
||||
self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'foo.pyo')))
|
||||
|
||||
def test_get_outputs(self):
|
||||
pkg_dir, dist = self.create_dist()
|
||||
|
@ -57,7 +57,7 @@ def test_get_outputs(self):
|
|||
cmd.distribution.script_name = 'setup.py'
|
||||
|
||||
# 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):
|
||||
pkg_dir, dist = self.create_dist()
|
||||
|
|
|
@ -23,15 +23,15 @@ def test_default_settings(self):
|
|||
skip_build=1,
|
||||
)
|
||||
cmd = install_scripts(dist)
|
||||
self.assert_(not cmd.force)
|
||||
self.assert_(not cmd.skip_build)
|
||||
self.assert_(cmd.build_dir is None)
|
||||
self.assert_(cmd.install_dir is None)
|
||||
self.assertTrue(not cmd.force)
|
||||
self.assertTrue(not cmd.skip_build)
|
||||
self.assertTrue(cmd.build_dir is None)
|
||||
self.assertTrue(cmd.install_dir is None)
|
||||
|
||||
cmd.finalize_options()
|
||||
|
||||
self.assert_(cmd.force)
|
||||
self.assert_(cmd.skip_build)
|
||||
self.assertTrue(cmd.force)
|
||||
self.assertTrue(cmd.skip_build)
|
||||
self.assertEqual(cmd.build_dir, "/foo/bar")
|
||||
self.assertEqual(cmd.install_dir, "/splat/funk")
|
||||
|
||||
|
@ -69,7 +69,7 @@ def write_script(name, text):
|
|||
|
||||
installed = os.listdir(target)
|
||||
for name in expected:
|
||||
self.assert_(name in installed)
|
||||
self.assertTrue(name in installed)
|
||||
|
||||
|
||||
def test_suite():
|
||||
|
|
|
@ -46,7 +46,7 @@ def test_reg_class(self):
|
|||
# windows registeries versions.
|
||||
path = r'Software\Microsoft\Notepad'
|
||||
v = Reg.get_value(path, "lfitalic")
|
||||
self.assert_(v in (0, 1))
|
||||
self.assertTrue(v in (0, 1))
|
||||
|
||||
import winreg
|
||||
HKCU = winreg.HKEY_CURRENT_USER
|
||||
|
@ -54,7 +54,7 @@ def test_reg_class(self):
|
|||
self.assertEquals(keys, None)
|
||||
|
||||
keys = Reg.read_keys(HKCU, r'Software\Microsoft')
|
||||
self.assert_('Notepad' in keys)
|
||||
self.assertTrue('Notepad' in keys)
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(msvc9compilerTestCase)
|
||||
|
|
|
@ -96,7 +96,7 @@ def test_create_pypirc(self):
|
|||
cmd = self._get_cmd()
|
||||
|
||||
# we shouldn't have a .pypirc file yet
|
||||
self.assert_(not os.path.exists(self.rc))
|
||||
self.assertTrue(not os.path.exists(self.rc))
|
||||
|
||||
# patching input and getpass.getpass
|
||||
# so register gets happy
|
||||
|
@ -115,7 +115,7 @@ def test_create_pypirc(self):
|
|||
del register_module.input
|
||||
|
||||
# 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
|
||||
content = open(self.rc).read()
|
||||
|
@ -133,13 +133,13 @@ def _no_way(prompt=''):
|
|||
|
||||
# let's see what the server received : we should
|
||||
# have 2 similar requests
|
||||
self.assert_(self.conn.reqs, 2)
|
||||
self.assertTrue(self.conn.reqs, 2)
|
||||
req1 = dict(self.conn.reqs[0].headers)
|
||||
req2 = dict(self.conn.reqs[1].headers)
|
||||
|
||||
self.assertEquals(req1['Content-length'], '1374')
|
||||
self.assertEquals(req2['Content-length'], '1374')
|
||||
self.assert_((b'xxx') in self.conn.reqs[1].data)
|
||||
self.assertTrue((b'xxx') in self.conn.reqs[1].data)
|
||||
|
||||
def test_password_not_in_file(self):
|
||||
|
||||
|
@ -165,11 +165,11 @@ def test_registering(self):
|
|||
del register_module.input
|
||||
|
||||
# we should have send a request
|
||||
self.assert_(self.conn.reqs, 1)
|
||||
self.assertTrue(self.conn.reqs, 1)
|
||||
req = self.conn.reqs[0]
|
||||
headers = dict(req.headers)
|
||||
self.assertEquals(headers['Content-length'], '608')
|
||||
self.assert_((b'tarek') in req.data)
|
||||
self.assertTrue((b'tarek') in req.data)
|
||||
|
||||
def test_password_reset(self):
|
||||
# this test runs choice 3
|
||||
|
@ -183,11 +183,11 @@ def test_password_reset(self):
|
|||
del register_module.input
|
||||
|
||||
# we should have send a request
|
||||
self.assert_(self.conn.reqs, 1)
|
||||
self.assertTrue(self.conn.reqs, 1)
|
||||
req = self.conn.reqs[0]
|
||||
headers = dict(req.headers)
|
||||
self.assertEquals(headers['Content-length'], '290')
|
||||
self.assert_((b'tarek') in req.data)
|
||||
self.assertTrue((b'tarek') in req.data)
|
||||
|
||||
def test_strict(self):
|
||||
# testing the script option
|
||||
|
|
|
@ -21,12 +21,12 @@ def tearDown(self):
|
|||
|
||||
def test_get_config_h_filename(self):
|
||||
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):
|
||||
lib_dir = sysconfig.get_python_lib()
|
||||
# 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?
|
||||
self.assertNotEqual(sysconfig.get_python_lib(),
|
||||
sysconfig.get_python_lib(prefix=TESTFN))
|
||||
|
@ -36,14 +36,14 @@ def test_get_python_inc(self):
|
|||
# This is not much of a test. We make sure Python.h exists
|
||||
# in the directory returned by get_python_inc() but we don't know
|
||||
# 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")
|
||||
self.assert_(os.path.isfile(python_h), python_h)
|
||||
self.assertTrue(os.path.isfile(python_h), python_h)
|
||||
|
||||
def test_get_config_vars(self):
|
||||
cvars = sysconfig.get_config_vars()
|
||||
self.assert_(isinstance(cvars, dict))
|
||||
self.assert_(cvars)
|
||||
self.assertTrue(isinstance(cvars, dict))
|
||||
self.assertTrue(cvars)
|
||||
|
||||
def test_customize_compiler(self):
|
||||
|
||||
|
|
|
@ -96,11 +96,11 @@ def test_upload(self):
|
|||
# what did we send ?
|
||||
headers = dict(self.last_open.req.headers)
|
||||
self.assertEquals(headers['Content-length'], '2087')
|
||||
self.assert_(headers['Content-type'].startswith('multipart/form-data'))
|
||||
self.assertTrue(headers['Content-type'].startswith('multipart/form-data'))
|
||||
self.assertEquals(self.last_open.req.get_method(), 'POST')
|
||||
self.assertEquals(self.last_open.req.get_full_url(),
|
||||
'http://pypi.python.org/pypi')
|
||||
self.assert_(b'xxx' in self.last_open.req.data)
|
||||
self.assertTrue(b'xxx' in self.last_open.req.data)
|
||||
|
||||
def test_suite():
|
||||
return unittest.makeSuite(uploadTestCase)
|
||||
|
|
|
@ -225,10 +225,10 @@ def test_strtobool(self):
|
|||
no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')
|
||||
|
||||
for y in yes:
|
||||
self.assert_(strtobool(y))
|
||||
self.assertTrue(strtobool(y))
|
||||
|
||||
for n in no:
|
||||
self.assert_(not strtobool(n))
|
||||
self.assertTrue(not strtobool(n))
|
||||
|
||||
def test_rfc822_escape(self):
|
||||
header = 'I am a\npoor\nlonesome\nheader\n'
|
||||
|
|
|
@ -53,7 +53,7 @@ def openfile(filename, *args, **kws):
|
|||
# Base test class
|
||||
class TestEmailBase(unittest.TestCase):
|
||||
def ndiffAssertEqual(self, first, second):
|
||||
"""Like failUnlessEqual except use ndiff for readable output."""
|
||||
"""Like assertEqual except use ndiff for readable output."""
|
||||
if first != second:
|
||||
sfirst = str(first)
|
||||
ssecond = str(second)
|
||||
|
@ -222,12 +222,12 @@ def test__contains__(self):
|
|||
msg['From'] = 'Me'
|
||||
msg['to'] = 'You'
|
||||
# Check for case insensitivity
|
||||
self.failUnless('from' in msg)
|
||||
self.failUnless('From' in msg)
|
||||
self.failUnless('FROM' in msg)
|
||||
self.failUnless('to' in msg)
|
||||
self.failUnless('To' in msg)
|
||||
self.failUnless('TO' in msg)
|
||||
self.assertTrue('from' in msg)
|
||||
self.assertTrue('From' in msg)
|
||||
self.assertTrue('FROM' in msg)
|
||||
self.assertTrue('to' in msg)
|
||||
self.assertTrue('To' in msg)
|
||||
self.assertTrue('TO' in msg)
|
||||
|
||||
def test_as_string(self):
|
||||
eq = self.ndiffAssertEqual
|
||||
|
@ -237,7 +237,7 @@ def test_as_string(self):
|
|||
eq(text, str(msg))
|
||||
fullrepr = msg.as_string(unixfrom=True)
|
||||
lines = fullrepr.split('\n')
|
||||
self.failUnless(lines[0].startswith('From '))
|
||||
self.assertTrue(lines[0].startswith('From '))
|
||||
eq(text, NL.join(lines[1:]))
|
||||
|
||||
def test_bad_param(self):
|
||||
|
@ -307,12 +307,12 @@ def test_get_param_with_semis_in_quotes(self):
|
|||
'"Jim&&Jill"')
|
||||
|
||||
def test_field_containment(self):
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
msg = email.message_from_string('Header: exists')
|
||||
unless('header' in msg)
|
||||
unless('Header' in msg)
|
||||
unless('HEADER' in msg)
|
||||
self.failIf('headerx' in msg)
|
||||
self.assertFalse('headerx' in msg)
|
||||
|
||||
def test_set_param(self):
|
||||
eq = self.assertEqual
|
||||
|
@ -952,7 +952,7 @@ def test_checkSetMinor(self):
|
|||
|
||||
def test_add_header(self):
|
||||
eq = self.assertEqual
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
self._au.add_header('Content-Disposition', 'attachment',
|
||||
filename='audiotest.au')
|
||||
eq(self._au['content-disposition'],
|
||||
|
@ -992,7 +992,7 @@ def test_checkSetMinor(self):
|
|||
|
||||
def test_add_header(self):
|
||||
eq = self.assertEqual
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
self._im.add_header('Content-Disposition', 'attachment',
|
||||
filename='dingusfish.gif')
|
||||
eq(self._im['content-disposition'],
|
||||
|
@ -1036,7 +1036,7 @@ def setUp(self):
|
|||
|
||||
def test_types(self):
|
||||
eq = self.assertEqual
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
eq(self._msg.get_content_type(), 'text/plain')
|
||||
eq(self._msg.get_param('charset'), 'us-ascii')
|
||||
missing = []
|
||||
|
@ -1046,7 +1046,7 @@ def test_types(self):
|
|||
|
||||
def test_payload(self):
|
||||
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):
|
||||
eq = self.assertEqual
|
||||
|
@ -1097,7 +1097,7 @@ def setUp(self):
|
|||
def test_hierarchy(self):
|
||||
# convenience
|
||||
eq = self.assertEqual
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
raises = self.assertRaises
|
||||
# tests
|
||||
m = self._msg
|
||||
|
@ -1411,7 +1411,7 @@ def test_boundary_with_leading_space(self):
|
|||
|
||||
-- XXXX--
|
||||
''')
|
||||
self.failUnless(msg.is_multipart())
|
||||
self.assertTrue(msg.is_multipart())
|
||||
eq(msg.get_boundary(), ' XXXX')
|
||||
eq(len(msg.get_payload()), 2)
|
||||
|
||||
|
@ -1441,7 +1441,7 @@ def test_parse_missing_minor_type(self):
|
|||
eq(msg.get_content_subtype(), 'plain')
|
||||
|
||||
def test_same_boundary_inner_outer(self):
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
msg = self._msgobj('msg_15.txt')
|
||||
# XXX We can probably eventually do better
|
||||
inner = msg.get_payload(0)
|
||||
|
@ -1451,7 +1451,7 @@ def test_same_boundary_inner_outer(self):
|
|||
errors.StartBoundaryNotFoundDefect))
|
||||
|
||||
def test_multipart_no_boundary(self):
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
msg = self._msgobj('msg_25.txt')
|
||||
unless(isinstance(msg.get_payload(), str))
|
||||
self.assertEqual(len(msg.defects), 2)
|
||||
|
@ -1509,7 +1509,7 @@ def test_no_separating_blank_line(self):
|
|||
""")
|
||||
|
||||
def test_lying_multipart(self):
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
msg = self._msgobj('msg_41.txt')
|
||||
unless(hasattr(msg, 'defects'))
|
||||
self.assertEqual(len(msg.defects), 2)
|
||||
|
@ -1529,7 +1529,7 @@ def test_missing_start_boundary(self):
|
|||
# [*] This message is missing its start boundary
|
||||
bad = outer.get_payload(1).get_payload(0)
|
||||
self.assertEqual(len(bad.defects), 1)
|
||||
self.failUnless(isinstance(bad.defects[0],
|
||||
self.assertTrue(isinstance(bad.defects[0],
|
||||
errors.StartBoundaryNotFoundDefect))
|
||||
|
||||
def test_first_line_is_continuation_header(self):
|
||||
|
@ -1539,7 +1539,7 @@ def test_first_line_is_continuation_header(self):
|
|||
eq(msg.keys(), [])
|
||||
eq(msg.get_payload(), 'Line 2\nLine 3')
|
||||
eq(len(msg.defects), 1)
|
||||
self.failUnless(isinstance(msg.defects[0],
|
||||
self.assertTrue(isinstance(msg.defects[0],
|
||||
errors.FirstHeaderLineIsContinuationDefect))
|
||||
eq(msg.defects[0].line, ' Line 1\n')
|
||||
|
||||
|
@ -1607,7 +1607,7 @@ def test_type_error(self):
|
|||
|
||||
def test_valid_argument(self):
|
||||
eq = self.assertEqual
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
subject = 'A sub-message'
|
||||
m = Message()
|
||||
m['Subject'] = subject
|
||||
|
@ -1651,20 +1651,20 @@ def test_generate(self):
|
|||
|
||||
def test_parse_message_rfc822(self):
|
||||
eq = self.assertEqual
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
msg = self._msgobj('msg_11.txt')
|
||||
eq(msg.get_content_type(), 'message/rfc822')
|
||||
payload = msg.get_payload()
|
||||
unless(isinstance(payload, list))
|
||||
eq(len(payload), 1)
|
||||
submsg = payload[0]
|
||||
self.failUnless(isinstance(submsg, Message))
|
||||
self.assertTrue(isinstance(submsg, Message))
|
||||
eq(submsg['subject'], 'An enclosed message')
|
||||
eq(submsg.get_payload(), 'Here is the body of the message.\n')
|
||||
|
||||
def test_dsn(self):
|
||||
eq = self.assertEqual
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
# msg 16 is a Delivery Status Notification, see RFC 1894
|
||||
msg = self._msgobj('msg_16.txt')
|
||||
eq(msg.get_content_type(), 'multipart/report')
|
||||
|
@ -2002,7 +2002,7 @@ def test_message_external_body_idempotent(self):
|
|||
|
||||
def test_content_type(self):
|
||||
eq = self.assertEquals
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
# Get a message object and reset the seek pointer for other tests
|
||||
msg, text = self._msgobj('msg_05.txt')
|
||||
eq(msg.get_content_type(), 'multipart/report')
|
||||
|
@ -2024,7 +2024,7 @@ def test_content_type(self):
|
|||
eq(msg2.get_payload(), 'Yadda yadda yadda\n')
|
||||
msg3 = msg.get_payload(2)
|
||||
eq(msg3.get_content_type(), 'message/rfc822')
|
||||
self.failUnless(isinstance(msg3, Message))
|
||||
self.assertTrue(isinstance(msg3, Message))
|
||||
payload = msg3.get_payload()
|
||||
unless(isinstance(payload, list))
|
||||
eq(len(payload), 1)
|
||||
|
@ -2034,7 +2034,7 @@ def test_content_type(self):
|
|||
|
||||
def test_parser(self):
|
||||
eq = self.assertEquals
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
msg, text = self._msgobj('msg_06.txt')
|
||||
# Check some of the outer headers
|
||||
eq(msg.get_content_type(), 'message/rfc822')
|
||||
|
@ -2044,9 +2044,9 @@ def test_parser(self):
|
|||
unless(isinstance(payload, list))
|
||||
eq(len(payload), 1)
|
||||
msg1 = payload[0]
|
||||
self.failUnless(isinstance(msg1, Message))
|
||||
self.assertTrue(isinstance(msg1, Message))
|
||||
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')
|
||||
|
||||
|
||||
|
@ -2077,7 +2077,7 @@ def test_message_from_file(self):
|
|||
self.assertEqual(text, s.getvalue())
|
||||
|
||||
def test_message_from_string_with_class(self):
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
with openfile('msg_01.txt') as fp:
|
||||
text = fp.read()
|
||||
|
||||
|
@ -2095,7 +2095,7 @@ class MyMessage(Message):
|
|||
unless(isinstance(subpart, MyMessage))
|
||||
|
||||
def test_message_from_file_with_class(self):
|
||||
unless = self.failUnless
|
||||
unless = self.assertTrue
|
||||
# Create a subclass
|
||||
class MyMessage(Message):
|
||||
pass
|
||||
|
@ -2217,7 +2217,7 @@ def test_quote_dump(self):
|
|||
|
||||
def test_charset_richcomparisons(self):
|
||||
eq = self.assertEqual
|
||||
ne = self.failIfEqual
|
||||
ne = self.assertNotEqual
|
||||
cset1 = Charset()
|
||||
cset2 = Charset()
|
||||
eq(cset1, 'us-ascii')
|
||||
|
@ -2410,8 +2410,8 @@ def test_header_parser(self):
|
|||
eq(msg['from'], 'ppp-request@zzz.org')
|
||||
eq(msg['to'], 'ppp@zzz.org')
|
||||
eq(msg.get_content_type(), 'multipart/mixed')
|
||||
self.failIf(msg.is_multipart())
|
||||
self.failUnless(isinstance(msg.get_payload(), str))
|
||||
self.assertFalse(msg.is_multipart())
|
||||
self.assertTrue(isinstance(msg.get_payload(), str))
|
||||
|
||||
def test_whitespace_continuation(self):
|
||||
eq = self.assertEqual
|
||||
|
@ -2613,18 +2613,18 @@ def setUp(self):
|
|||
|
||||
def test_quopri_header_check(self):
|
||||
for c in self.hlit:
|
||||
self.failIf(quoprimime.header_check(c),
|
||||
self.assertFalse(quoprimime.header_check(c),
|
||||
'Should not be header quopri encoded: %s' % chr(c))
|
||||
for c in self.hnon:
|
||||
self.failUnless(quoprimime.header_check(c),
|
||||
self.assertTrue(quoprimime.header_check(c),
|
||||
'Should be header quopri encoded: %s' % chr(c))
|
||||
|
||||
def test_quopri_body_check(self):
|
||||
for c in self.blit:
|
||||
self.failIf(quoprimime.body_check(c),
|
||||
self.assertFalse(quoprimime.body_check(c),
|
||||
'Should not be body quopri encoded: %s' % chr(c))
|
||||
for c in self.bnon:
|
||||
self.failUnless(quoprimime.body_check(c),
|
||||
self.assertTrue(quoprimime.body_check(c),
|
||||
'Should be body quopri encoded: %s' % chr(c))
|
||||
|
||||
def test_header_quopri_len(self):
|
||||
|
@ -2789,7 +2789,7 @@ def test_long(self):
|
|||
h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.",
|
||||
maxlinelen=76)
|
||||
for l in h.encode(splitchars=' ').split('\n '):
|
||||
self.failUnless(len(l) <= 76)
|
||||
self.assertTrue(len(l) <= 76)
|
||||
|
||||
def test_multilingual(self):
|
||||
eq = self.ndiffAssertEqual
|
||||
|
@ -3166,7 +3166,7 @@ def test_rfc2231_no_language_or_charset(self):
|
|||
'''
|
||||
msg = email.message_from_string(m)
|
||||
param = msg.get_param('NAME')
|
||||
self.failIf(isinstance(param, tuple))
|
||||
self.assertFalse(isinstance(param, tuple))
|
||||
self.assertEqual(
|
||||
param,
|
||||
'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm')
|
||||
|
@ -3319,7 +3319,7 @@ def test_rfc2231_single_tick_in_filename(self):
|
|||
"""
|
||||
msg = email.message_from_string(m)
|
||||
param = msg.get_param('name')
|
||||
self.failIf(isinstance(param, tuple))
|
||||
self.assertFalse(isinstance(param, tuple))
|
||||
self.assertEqual(param, "Frank's Document")
|
||||
|
||||
def test_rfc2231_tick_attack_extended(self):
|
||||
|
@ -3343,7 +3343,7 @@ def test_rfc2231_tick_attack(self):
|
|||
"""
|
||||
msg = email.message_from_string(m)
|
||||
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")
|
||||
|
||||
def test_rfc2231_no_extended_values(self):
|
||||
|
|
|
@ -14,7 +14,7 @@ def test_module(self):
|
|||
# Common case.
|
||||
with util.uncache(builtin_util.NAME):
|
||||
found = machinery.BuiltinImporter.find_module(builtin_util.NAME)
|
||||
self.assert_(found)
|
||||
self.assertTrue(found)
|
||||
|
||||
def test_package(self):
|
||||
# Built-in modules cannot be a package.
|
||||
|
@ -35,14 +35,14 @@ def test_package_over_module(self):
|
|||
def test_failure(self):
|
||||
assert 'importlib' not in sys.builtin_module_names
|
||||
loader = machinery.BuiltinImporter.find_module('importlib')
|
||||
self.assert_(loader is None)
|
||||
self.assertTrue(loader is None)
|
||||
|
||||
def test_ignore_path(self):
|
||||
# The value for 'path' should always trigger a failed import.
|
||||
with util.uncache(builtin_util.NAME):
|
||||
loader = machinery.BuiltinImporter.find_module(builtin_util.NAME,
|
||||
['pkg'])
|
||||
self.assert_(loader is None)
|
||||
self.assertTrue(loader is None)
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -18,10 +18,10 @@ class LoaderTests(abc.LoaderTests):
|
|||
|
||||
def verify(self, module):
|
||||
"""Verify that the module matches against what it should have."""
|
||||
self.assert_(isinstance(module, types.ModuleType))
|
||||
self.assertTrue(isinstance(module, types.ModuleType))
|
||||
for attr, value in self.verification.items():
|
||||
self.assertEqual(getattr(module, attr), value)
|
||||
self.assert_(module.__name__ in sys.modules)
|
||||
self.assertTrue(module.__name__ in sys.modules)
|
||||
|
||||
load_module = staticmethod(lambda name:
|
||||
machinery.BuiltinImporter.load_module(name))
|
||||
|
@ -49,7 +49,7 @@ def test_module_reuse(self):
|
|||
with util.uncache(builtin_util.NAME):
|
||||
module1 = self.load_module(builtin_util.NAME)
|
||||
module2 = self.load_module(builtin_util.NAME)
|
||||
self.assert_(module1 is module2)
|
||||
self.assertTrue(module1 is module2)
|
||||
|
||||
def test_unloadable(self):
|
||||
name = 'dssdsdfff'
|
||||
|
@ -70,17 +70,17 @@ class InspectLoaderTests(unittest.TestCase):
|
|||
def test_get_code(self):
|
||||
# There is no code object.
|
||||
result = machinery.BuiltinImporter.get_code(builtin_util.NAME)
|
||||
self.assert_(result is None)
|
||||
self.assertTrue(result is None)
|
||||
|
||||
def test_get_source(self):
|
||||
# There is no source.
|
||||
result = machinery.BuiltinImporter.get_source(builtin_util.NAME)
|
||||
self.assert_(result is None)
|
||||
self.assertTrue(result is None)
|
||||
|
||||
def test_is_package(self):
|
||||
# Cannot be a package.
|
||||
result = machinery.BuiltinImporter.is_package(builtin_util.NAME)
|
||||
self.assert_(not result)
|
||||
self.assertTrue(not result)
|
||||
|
||||
def test_not_builtin(self):
|
||||
# Modules not built-in should raise ImportError.
|
||||
|
|
|
@ -13,7 +13,7 @@ def find_module(self, fullname):
|
|||
return importer.find_module(fullname)
|
||||
|
||||
def test_module(self):
|
||||
self.assert_(self.find_module(util.NAME))
|
||||
self.assertTrue(self.find_module(util.NAME))
|
||||
|
||||
def test_package(self):
|
||||
# Extension modules cannot be an __init__ for a package.
|
||||
|
@ -32,7 +32,7 @@ def test_package_over_module(self):
|
|||
pass
|
||||
|
||||
def test_failure(self):
|
||||
self.assert_(self.find_module('asdfjkl;') is None)
|
||||
self.assertTrue(self.find_module('asdfjkl;') is None)
|
||||
|
||||
# XXX Raise an exception if someone tries to use the 'path' argument?
|
||||
|
||||
|
|
|
@ -23,8 +23,8 @@ def test_module(self):
|
|||
('__file__', ext_util.FILEPATH),
|
||||
('__package__', '')]:
|
||||
self.assertEqual(getattr(module, attr), value)
|
||||
self.assert_(ext_util.NAME in sys.modules)
|
||||
self.assert_(isinstance(module.__loader__,
|
||||
self.assertTrue(ext_util.NAME in sys.modules)
|
||||
self.assertTrue(isinstance(module.__loader__,
|
||||
_bootstrap._ExtensionFileLoader))
|
||||
|
||||
def test_package(self):
|
||||
|
@ -39,7 +39,7 @@ def test_module_reuse(self):
|
|||
with util.uncache(ext_util.NAME):
|
||||
module1 = self.load_module(ext_util.NAME)
|
||||
module2 = self.load_module(ext_util.NAME)
|
||||
self.assert_(module1 is module2)
|
||||
self.assertTrue(module1 is module2)
|
||||
|
||||
def test_state_after_failure(self):
|
||||
# No easy way to trigger a failure after a successful import.
|
||||
|
|
|
@ -19,7 +19,7 @@ def hook(self, entry):
|
|||
def test_success(self):
|
||||
# Path hook should handle a directory where a known extension module
|
||||
# exists.
|
||||
self.assert_(hasattr(self.hook(util.PATH), 'find_module'))
|
||||
self.assertTrue(hasattr(self.hook(util.PATH), 'find_module'))
|
||||
|
||||
|
||||
def test_main():
|
||||
|
|
|
@ -15,15 +15,15 @@ def find(self, name, path=None):
|
|||
def test_module(self):
|
||||
name = '__hello__'
|
||||
loader = self.find(name)
|
||||
self.assert_(hasattr(loader, 'load_module'))
|
||||
self.assertTrue(hasattr(loader, 'load_module'))
|
||||
|
||||
def test_package(self):
|
||||
loader = self.find('__phello__')
|
||||
self.assert_(hasattr(loader, 'load_module'))
|
||||
self.assertTrue(hasattr(loader, 'load_module'))
|
||||
|
||||
def test_module_in_package(self):
|
||||
loader = self.find('__phello__.spam', ['__phello__'])
|
||||
self.assert_(hasattr(loader, 'load_module'))
|
||||
self.assertTrue(hasattr(loader, 'load_module'))
|
||||
|
||||
def test_package_in_package(self):
|
||||
# No frozen package within another package to test with.
|
||||
|
@ -35,7 +35,7 @@ def test_package_over_module(self):
|
|||
|
||||
def test_failure(self):
|
||||
loader = self.find('<not real>')
|
||||
self.assert_(loader is None)
|
||||
self.assertTrue(loader is None)
|
||||
|
||||
|
||||
def test_main():
|
||||
|
|
|
@ -43,7 +43,7 @@ def test_module_reuse(self):
|
|||
with util.uncache('__hello__'):
|
||||
module1 = machinery.FrozenImporter.load_module('__hello__')
|
||||
module2 = machinery.FrozenImporter.load_module('__hello__')
|
||||
self.assert_(module1 is module2)
|
||||
self.assertTrue(module1 is module2)
|
||||
|
||||
def test_state_after_failure(self):
|
||||
# No way to trigger an error in a frozen module.
|
||||
|
@ -65,12 +65,12 @@ def test_get_code(self):
|
|||
code = machinery.FrozenImporter.get_code(name)
|
||||
mod = imp.new_module(name)
|
||||
exec(code, mod.__dict__)
|
||||
self.assert_(hasattr(mod, 'initialized'))
|
||||
self.assertTrue(hasattr(mod, 'initialized'))
|
||||
|
||||
def test_get_source(self):
|
||||
# Should always return None.
|
||||
result = machinery.FrozenImporter.get_source('__hello__')
|
||||
self.assert_(result is None)
|
||||
self.assertTrue(result is None)
|
||||
|
||||
def test_is_package(self):
|
||||
# Should be able to tell what is a package.
|
||||
|
@ -78,7 +78,7 @@ def test_is_package(self):
|
|||
('__phello__.spam', False))
|
||||
for name, is_package in test_for:
|
||||
result = machinery.FrozenImporter.is_package(name)
|
||||
self.assert_(bool(result) == is_package)
|
||||
self.assertTrue(bool(result) == is_package)
|
||||
|
||||
def test_failure(self):
|
||||
# Raise ImportError for modules that are not frozen.
|
||||
|
|
|
@ -53,8 +53,8 @@ def test_using_cache_for_assigning_to_attribute(self):
|
|||
with self.create_mock('pkg.__init__', 'pkg.module') as importer:
|
||||
with util.import_state(meta_path=[importer]):
|
||||
module = import_util.import_('pkg.module')
|
||||
self.assert_(hasattr(module, 'module'))
|
||||
self.assert_(id(module.module), id(sys.modules['pkg.module']))
|
||||
self.assertTrue(hasattr(module, 'module'))
|
||||
self.assertTrue(id(module.module), id(sys.modules['pkg.module']))
|
||||
|
||||
# See test_using_cache_after_loader() for reasoning.
|
||||
@import_util.importlib_only
|
||||
|
@ -63,7 +63,7 @@ def test_using_cache_for_fromlist(self):
|
|||
with self.create_mock('pkg.__init__', 'pkg.module') as importer:
|
||||
with util.import_state(meta_path=[importer]):
|
||||
module = import_util.import_('pkg', fromlist=['module'])
|
||||
self.assert_(hasattr(module, 'module'))
|
||||
self.assertTrue(hasattr(module, 'module'))
|
||||
self.assertEquals(id(module.module),
|
||||
id(sys.modules['pkg.module']))
|
||||
|
||||
|
|
|
@ -59,7 +59,7 @@ def test_unexistent_object(self):
|
|||
with util.import_state(meta_path=[importer]):
|
||||
module = import_util.import_('module', fromlist=['non_existent'])
|
||||
self.assertEquals(module.__name__, 'module')
|
||||
self.assert_(not hasattr(module, 'non_existent'))
|
||||
self.assertTrue(not hasattr(module, 'non_existent'))
|
||||
|
||||
def test_module_from_package(self):
|
||||
# [module]
|
||||
|
@ -67,7 +67,7 @@ def test_module_from_package(self):
|
|||
with util.import_state(meta_path=[importer]):
|
||||
module = import_util.import_('pkg', fromlist=['module'])
|
||||
self.assertEquals(module.__name__, 'pkg')
|
||||
self.assert_(hasattr(module, 'module'))
|
||||
self.assertTrue(hasattr(module, 'module'))
|
||||
self.assertEquals(module.module.__name__, 'pkg.module')
|
||||
|
||||
def test_no_module_from_package(self):
|
||||
|
@ -76,7 +76,7 @@ def test_no_module_from_package(self):
|
|||
with util.import_state(meta_path=[importer]):
|
||||
module = import_util.import_('pkg', fromlist='non_existent')
|
||||
self.assertEquals(module.__name__, 'pkg')
|
||||
self.assert_(not hasattr(module, 'non_existent'))
|
||||
self.assertTrue(not hasattr(module, 'non_existent'))
|
||||
|
||||
def test_empty_string(self):
|
||||
with util.mock_modules('pkg.__init__', 'pkg.mod') as importer:
|
||||
|
@ -91,7 +91,7 @@ def test_using_star(self):
|
|||
mock['pkg'].__all__ = ['module']
|
||||
module = import_util.import_('pkg', fromlist=['*'])
|
||||
self.assertEquals(module.__name__, 'pkg')
|
||||
self.assert_(hasattr(module, 'module'))
|
||||
self.assertTrue(hasattr(module, 'module'))
|
||||
self.assertEqual(module.module.__name__, 'pkg.module')
|
||||
|
||||
def test_star_with_others(self):
|
||||
|
@ -102,8 +102,8 @@ def test_star_with_others(self):
|
|||
mock['pkg'].__all__ = ['module1']
|
||||
module = import_util.import_('pkg', fromlist=['module2', '*'])
|
||||
self.assertEquals(module.__name__, 'pkg')
|
||||
self.assert_(hasattr(module, 'module1'))
|
||||
self.assert_(hasattr(module, 'module2'))
|
||||
self.assertTrue(hasattr(module, 'module1'))
|
||||
self.assertTrue(hasattr(module, 'module2'))
|
||||
self.assertEquals(module.module1.__name__, 'pkg.module1')
|
||||
self.assertEquals(module.module2.__name__, 'pkg.module2')
|
||||
|
||||
|
|
|
@ -64,7 +64,7 @@ def test_no_path(self):
|
|||
self.assertEquals(len(args), 2)
|
||||
self.assertEquals(len(kwargs), 0)
|
||||
self.assertEquals(args[0], mod_name)
|
||||
self.assert_(args[1] is None)
|
||||
self.assertTrue(args[1] is None)
|
||||
|
||||
def test_with_path(self):
|
||||
# [path set]
|
||||
|
@ -82,9 +82,9 @@ def test_with_path(self):
|
|||
args = log[1][0]
|
||||
kwargs = log[1][1]
|
||||
# Assuming all arguments are positional.
|
||||
self.assert_(not kwargs)
|
||||
self.assertTrue(not kwargs)
|
||||
self.assertEquals(args[0], mod_name)
|
||||
self.assert_(args[1] is path)
|
||||
self.assertTrue(args[1] is path)
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -13,7 +13,7 @@ def test_import_parent(self):
|
|||
with util.mock_modules('pkg.__init__', 'pkg.module') as mock:
|
||||
with util.import_state(meta_path=[mock]):
|
||||
module = import_util.import_('pkg.module')
|
||||
self.assert_('pkg' in sys.modules)
|
||||
self.assertTrue('pkg' in sys.modules)
|
||||
|
||||
def test_bad_parent(self):
|
||||
with util.mock_modules('pkg.module') as mock:
|
||||
|
|
|
@ -19,7 +19,7 @@ def test_failure(self):
|
|||
# Test None returned upon not finding a suitable finder.
|
||||
module = '<test module>'
|
||||
with util.import_state():
|
||||
self.assert_(machinery.PathFinder.find_module(module) is None)
|
||||
self.assertTrue(machinery.PathFinder.find_module(module) is None)
|
||||
|
||||
def test_sys_path(self):
|
||||
# Test that sys.path is used when 'path' is None.
|
||||
|
@ -30,7 +30,7 @@ def test_sys_path(self):
|
|||
with util.import_state(path_importer_cache={path: importer},
|
||||
path=[path]):
|
||||
loader = machinery.PathFinder.find_module(module)
|
||||
self.assert_(loader is importer)
|
||||
self.assertTrue(loader is importer)
|
||||
|
||||
def test_path(self):
|
||||
# Test that 'path' is used when set.
|
||||
|
@ -40,7 +40,7 @@ def test_path(self):
|
|||
importer = util.mock_modules(module)
|
||||
with util.import_state(path_importer_cache={path: importer}):
|
||||
loader = machinery.PathFinder.find_module(module, [path])
|
||||
self.assert_(loader is importer)
|
||||
self.assertTrue(loader is importer)
|
||||
|
||||
def test_path_hooks(self):
|
||||
# Test that sys.path_hooks is used.
|
||||
|
@ -51,16 +51,16 @@ def test_path_hooks(self):
|
|||
hook = import_util.mock_path_hook(path, importer=importer)
|
||||
with util.import_state(path_hooks=[hook]):
|
||||
loader = machinery.PathFinder.find_module(module, [path])
|
||||
self.assert_(loader is importer)
|
||||
self.assert_(path in sys.path_importer_cache)
|
||||
self.assert_(sys.path_importer_cache[path] is importer)
|
||||
self.assertTrue(loader is importer)
|
||||
self.assertTrue(path in sys.path_importer_cache)
|
||||
self.assertTrue(sys.path_importer_cache[path] is importer)
|
||||
|
||||
def test_path_importer_cache_has_None(self):
|
||||
# Test that if sys.path_importer_cache has None that None is returned.
|
||||
clear_cache = {path: None for path in sys.path}
|
||||
with util.import_state(path_importer_cache=clear_cache):
|
||||
for name in ('asynchat', 'sys', '<test module>'):
|
||||
self.assert_(machinery.PathFinder.find_module(name) is None)
|
||||
self.assertTrue(machinery.PathFinder.find_module(name) is None)
|
||||
|
||||
def test_path_importer_cache_has_None_continues(self):
|
||||
# Test that having None in sys.path_importer_cache causes the search to
|
||||
|
@ -71,7 +71,7 @@ def test_path_importer_cache_has_None_continues(self):
|
|||
with util.import_state(path=['1', '2'],
|
||||
path_importer_cache={'1': None, '2': importer}):
|
||||
loader = machinery.PathFinder.find_module(module)
|
||||
self.assert_(loader is importer)
|
||||
self.assertTrue(loader is importer)
|
||||
|
||||
|
||||
|
||||
|
@ -88,15 +88,15 @@ def test_implicit_hooks(self):
|
|||
with util.import_state():
|
||||
nothing = _bootstrap._DefaultPathFinder.find_module(module,
|
||||
path=[existing_path])
|
||||
self.assert_(nothing is None)
|
||||
self.assert_(existing_path in sys.path_importer_cache)
|
||||
self.assert_(not isinstance(sys.path_importer_cache[existing_path],
|
||||
self.assertTrue(nothing is None)
|
||||
self.assertTrue(existing_path in sys.path_importer_cache)
|
||||
self.assertTrue(not isinstance(sys.path_importer_cache[existing_path],
|
||||
imp.NullImporter))
|
||||
nothing = _bootstrap._DefaultPathFinder.find_module(module,
|
||||
path=[bad_path])
|
||||
self.assert_(nothing is None)
|
||||
self.assert_(bad_path in sys.path_importer_cache)
|
||||
self.assert_(isinstance(sys.path_importer_cache[bad_path],
|
||||
self.assertTrue(nothing is None)
|
||||
self.assertTrue(bad_path in sys.path_importer_cache)
|
||||
self.assertTrue(isinstance(sys.path_importer_cache[bad_path],
|
||||
imp.NullImporter))
|
||||
|
||||
def test_path_importer_cache_has_None(self):
|
||||
|
@ -113,7 +113,7 @@ def test_path_importer_cache_has_None(self):
|
|||
with util.import_state(path_importer_cache={path: None}):
|
||||
loader = _bootstrap._DefaultPathFinder.find_module(module,
|
||||
path=[path])
|
||||
self.assert_(loader is importer)
|
||||
self.assertTrue(loader is importer)
|
||||
finally:
|
||||
_bootstrap._DEFAULT_PATH_HOOK = original_hook
|
||||
|
||||
|
|
|
@ -79,7 +79,7 @@ def callback(global_):
|
|||
import_util.import_('pkg') # For __import__().
|
||||
module = import_util.import_('', global_, fromlist=['mod2'], level=1)
|
||||
self.assertEqual(module.__name__, 'pkg')
|
||||
self.assert_(hasattr(module, 'mod2'))
|
||||
self.assertTrue(hasattr(module, 'mod2'))
|
||||
self.assertEqual(module.mod2.attr, 'pkg.mod2')
|
||||
self.relative_import_test(create, globals_, callback)
|
||||
|
||||
|
@ -105,7 +105,7 @@ def callback(global_):
|
|||
module = import_util.import_('', global_, fromlist=['module'],
|
||||
level=1)
|
||||
self.assertEqual(module.__name__, 'pkg')
|
||||
self.assert_(hasattr(module, 'module'))
|
||||
self.assertTrue(hasattr(module, 'module'))
|
||||
self.assertEqual(module.module.attr, 'pkg.module')
|
||||
self.relative_import_test(create, globals_, callback)
|
||||
|
||||
|
@ -129,7 +129,7 @@ def callback(global_):
|
|||
module = import_util.import_('', global_, fromlist=['subpkg2'],
|
||||
level=2)
|
||||
self.assertEqual(module.__name__, 'pkg')
|
||||
self.assert_(hasattr(module, 'subpkg2'))
|
||||
self.assertTrue(hasattr(module, 'subpkg2'))
|
||||
self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__')
|
||||
|
||||
def test_deep_import(self):
|
||||
|
|
|
@ -133,10 +133,10 @@ def test_module(self):
|
|||
mock = self.mocker({name: path})
|
||||
with util.uncache(name):
|
||||
module = mock.load_module(name)
|
||||
self.assert_(name in sys.modules)
|
||||
self.assertTrue(name in sys.modules)
|
||||
self.eq_attrs(module, __name__=name, __file__=path, __package__='',
|
||||
__loader__=mock)
|
||||
self.assert_(not hasattr(module, '__path__'))
|
||||
self.assertTrue(not hasattr(module, '__path__'))
|
||||
return mock, name
|
||||
|
||||
def test_package(self):
|
||||
|
@ -145,7 +145,7 @@ def test_package(self):
|
|||
mock = self.mocker({name: path})
|
||||
with util.uncache(name):
|
||||
module = mock.load_module(name)
|
||||
self.assert_(name in sys.modules)
|
||||
self.assertTrue(name in sys.modules)
|
||||
self.eq_attrs(module, __name__=name, __file__=path,
|
||||
__path__=[os.path.dirname(path)], __package__=name,
|
||||
__loader__=mock)
|
||||
|
@ -171,8 +171,8 @@ def test_module_reuse(self):
|
|||
with util.uncache(name):
|
||||
sys.modules[name] = module
|
||||
loaded_module = mock.load_module(name)
|
||||
self.assert_(loaded_module is module)
|
||||
self.assert_(sys.modules[name] is module)
|
||||
self.assertTrue(loaded_module is module)
|
||||
self.assertTrue(sys.modules[name] is module)
|
||||
return mock, name
|
||||
|
||||
def test_state_after_failure(self):
|
||||
|
@ -184,8 +184,8 @@ def test_state_after_failure(self):
|
|||
with util.uncache(name):
|
||||
sys.modules[name] = module
|
||||
self.assertRaises(ZeroDivisionError, mock.load_module, name)
|
||||
self.assert_(sys.modules[name] is module)
|
||||
self.assert_(hasattr(module, 'blah'))
|
||||
self.assertTrue(sys.modules[name] is module)
|
||||
self.assertTrue(hasattr(module, 'blah'))
|
||||
return mock
|
||||
|
||||
def test_unloadable(self):
|
||||
|
@ -194,7 +194,7 @@ def test_unloadable(self):
|
|||
mock.source = b"1/0"
|
||||
with util.uncache(name):
|
||||
self.assertRaises(ZeroDivisionError, mock.load_module, name)
|
||||
self.assert_(name not in sys.modules)
|
||||
self.assertTrue(name not in sys.modules)
|
||||
return mock
|
||||
|
||||
|
||||
|
@ -293,7 +293,7 @@ def run_test(self, dont_write_bytecode):
|
|||
sys.dont_write_bytecode = dont_write_bytecode
|
||||
with util.uncache(name):
|
||||
mock.load_module(name)
|
||||
self.assert_((name in mock.module_bytecode) is not
|
||||
self.assertTrue((name in mock.module_bytecode) is not
|
||||
dont_write_bytecode)
|
||||
|
||||
def test_no_bytecode_written(self):
|
||||
|
@ -319,7 +319,7 @@ def test_different_magic(self):
|
|||
'magic': bad_magic}})
|
||||
with util.uncache(name):
|
||||
mock.load_module(name)
|
||||
self.assert_(name in mock.module_bytecode)
|
||||
self.assertTrue(name in mock.module_bytecode)
|
||||
magic = mock.module_bytecode[name][:4]
|
||||
self.assertEqual(magic, imp.get_magic())
|
||||
|
||||
|
@ -332,7 +332,7 @@ def test_old_mtime(self):
|
|||
{name: {'path': 'path/to/mod.bytecode', 'mtime': old_mtime}})
|
||||
with util.uncache(name):
|
||||
mock.load_module(name)
|
||||
self.assert_(name in mock.module_bytecode)
|
||||
self.assertTrue(name in mock.module_bytecode)
|
||||
mtime = importlib._r_long(mock.module_bytecode[name][4:8])
|
||||
self.assertEqual(mtime, PyPycLoaderMock.default_mtime)
|
||||
|
||||
|
|
|
@ -23,7 +23,7 @@ def test_module(self):
|
|||
loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'],
|
||||
False)
|
||||
module = loader.load_module('_temp')
|
||||
self.assert_('_temp' in sys.modules)
|
||||
self.assertTrue('_temp' in sys.modules)
|
||||
check = {'__name__': '_temp', '__file__': mapping['_temp'],
|
||||
'__package__': ''}
|
||||
for attr, value in check.items():
|
||||
|
@ -35,7 +35,7 @@ def test_package(self):
|
|||
mapping['_pkg.__init__'],
|
||||
True)
|
||||
module = loader.load_module('_pkg')
|
||||
self.assert_('_pkg' in sys.modules)
|
||||
self.assertTrue('_pkg' in sys.modules)
|
||||
check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'],
|
||||
'__path__': [os.path.dirname(mapping['_pkg.__init__'])],
|
||||
'__package__': '_pkg'}
|
||||
|
@ -48,7 +48,7 @@ def test_lacking_parent(self):
|
|||
loader = _bootstrap._PyPycFileLoader('_pkg.mod',
|
||||
mapping['_pkg.mod'], False)
|
||||
module = loader.load_module('_pkg.mod')
|
||||
self.assert_('_pkg.mod' in sys.modules)
|
||||
self.assertTrue('_pkg.mod' in sys.modules)
|
||||
check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'],
|
||||
'__package__': '_pkg'}
|
||||
for attr, value in check.items():
|
||||
|
@ -73,7 +73,7 @@ def test_module_reuse(self):
|
|||
# than the original mtime.
|
||||
loader.source_mtime = self.fake_mtime(loader.source_mtime)
|
||||
module = loader.load_module('_temp')
|
||||
self.assert_('testing_var' in module.__dict__,
|
||||
self.assertTrue('testing_var' in module.__dict__,
|
||||
"'testing_var' not in "
|
||||
"{0}".format(list(module.__dict__.keys())))
|
||||
self.assertEqual(module, sys.modules['_temp'])
|
||||
|
@ -105,7 +105,7 @@ def test_bad_syntax(self):
|
|||
loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'],
|
||||
False)
|
||||
self.assertRaises(SyntaxError, loader.load_module, '_temp')
|
||||
self.assert_('_temp' not in sys.modules)
|
||||
self.assertTrue('_temp' not in sys.modules)
|
||||
|
||||
|
||||
class BadBytecodeTest(unittest.TestCase):
|
||||
|
@ -124,7 +124,7 @@ class BadBytecodeTest(unittest.TestCase):
|
|||
def import_(self, file, module_name):
|
||||
loader = _bootstrap._PyPycFileLoader(module_name, file, False)
|
||||
module = loader.load_module(module_name)
|
||||
self.assert_(module_name in sys.modules)
|
||||
self.assertTrue(module_name in sys.modules)
|
||||
|
||||
# [bad magic]
|
||||
@source_util.writes_bytecode_files
|
||||
|
@ -168,7 +168,7 @@ def test_bad_marshal(self):
|
|||
bytecode_file.write(b'AAAA')
|
||||
self.assertRaises(ValueError, self.import_, mapping['_temp'],
|
||||
'_temp')
|
||||
self.assert_('_temp' not in sys.modules)
|
||||
self.assertTrue('_temp' not in sys.modules)
|
||||
|
||||
|
||||
def test_main():
|
||||
|
|
|
@ -53,7 +53,7 @@ def run_test(self, test, create=None, *, compile_=None, unlink=None):
|
|||
for name in unlink:
|
||||
os.unlink(mapping[name])
|
||||
loader = self.import_(mapping['.root'], test)
|
||||
self.assert_(hasattr(loader, 'load_module'))
|
||||
self.assertTrue(hasattr(loader, 'load_module'))
|
||||
return loader
|
||||
|
||||
def test_module(self):
|
||||
|
@ -79,7 +79,7 @@ def test_module_in_package(self):
|
|||
with source_util.create_modules('pkg.__init__', 'pkg.sub') as mapping:
|
||||
pkg_dir = os.path.dirname(mapping['pkg.__init__'])
|
||||
loader = self.import_(pkg_dir, 'pkg.sub')
|
||||
self.assert_(hasattr(loader, 'load_module'))
|
||||
self.assertTrue(hasattr(loader, 'load_module'))
|
||||
|
||||
# [sub package]
|
||||
def test_package_in_package(self):
|
||||
|
@ -87,7 +87,7 @@ def test_package_in_package(self):
|
|||
with context as mapping:
|
||||
pkg_dir = os.path.dirname(mapping['pkg.__init__'])
|
||||
loader = self.import_(pkg_dir, 'pkg.sub')
|
||||
self.assert_(hasattr(loader, 'load_module'))
|
||||
self.assertTrue(hasattr(loader, 'load_module'))
|
||||
|
||||
# [sub empty]
|
||||
def test_empty_sub_directory(self):
|
||||
|
@ -105,13 +105,13 @@ def test_package_over_module(self):
|
|||
# XXX This is not a blackbox test!
|
||||
name = '_temp'
|
||||
loader = self.run_test(name, {'{0}.__init__'.format(name), name})
|
||||
self.assert_('__init__' in loader._base_path)
|
||||
self.assertTrue('__init__' in loader._base_path)
|
||||
|
||||
|
||||
def test_failure(self):
|
||||
with source_util.create_modules('blah') as mapping:
|
||||
nothing = self.import_(mapping['.root'], 'sdfsadsadf')
|
||||
self.assert_(nothing is None)
|
||||
self.assertTrue(nothing is None)
|
||||
|
||||
# [empty dir]
|
||||
def test_empty_dir(self):
|
||||
|
|
|
@ -10,7 +10,7 @@ class PathHookTest(unittest.TestCase):
|
|||
def test_success(self):
|
||||
# XXX Only work on existing directories?
|
||||
with source_util.create_modules('dummy') as mapping:
|
||||
self.assert_(hasattr(_bootstrap._FileFinder(mapping['.root']),
|
||||
self.assertTrue(hasattr(_bootstrap._FileFinder(mapping['.root']),
|
||||
'find_module'))
|
||||
|
||||
|
||||
|
|
|
@ -11,7 +11,7 @@ class SubclassTests(unittest.TestCase):
|
|||
def verify(self, ABC, *classes):
|
||||
"""Verify the classes are subclasses of the ABC."""
|
||||
for cls in classes:
|
||||
self.assert_(issubclass(cls, ABC))
|
||||
self.assertTrue(issubclass(cls, ABC))
|
||||
|
||||
def test_Finder(self):
|
||||
self.verify(abc.Finder, machinery.BuiltinImporter,
|
||||
|
|
|
@ -29,8 +29,8 @@ def test_new_module(self):
|
|||
module_name = 'a.b.c'
|
||||
with test_util.uncache(module_name):
|
||||
module = self.return_module(module_name)
|
||||
self.assert_(module_name in sys.modules)
|
||||
self.assert_(isinstance(module, types.ModuleType))
|
||||
self.assertTrue(module_name in sys.modules)
|
||||
self.assertTrue(isinstance(module, types.ModuleType))
|
||||
self.assertEqual(module.__name__, module_name)
|
||||
|
||||
def test_reload(self):
|
||||
|
@ -40,7 +40,7 @@ def test_reload(self):
|
|||
with test_util.uncache(name):
|
||||
sys.modules[name] = module
|
||||
returned_module = self.return_module(name)
|
||||
self.assert_(sys.modules[name] is returned_module)
|
||||
self.assertTrue(sys.modules[name] is returned_module)
|
||||
|
||||
def test_new_module_failure(self):
|
||||
# Test that a module is removed from sys.modules if added but an
|
||||
|
@ -48,7 +48,7 @@ def test_new_module_failure(self):
|
|||
name = 'a.b.c'
|
||||
with test_util.uncache(name):
|
||||
self.raise_exception(name)
|
||||
self.assert_(name not in sys.modules)
|
||||
self.assertTrue(name not in sys.modules)
|
||||
|
||||
def test_reload_failure(self):
|
||||
# Test that a failure on reload leaves the module in-place.
|
||||
|
@ -57,7 +57,7 @@ def test_reload_failure(self):
|
|||
with test_util.uncache(name):
|
||||
sys.modules[name] = module
|
||||
self.raise_exception(name)
|
||||
self.assert_(sys.modules[name] is module)
|
||||
self.assertTrue(sys.modules[name] is module)
|
||||
|
||||
|
||||
class SetPackageTests(unittest.TestCase):
|
||||
|
@ -71,7 +71,7 @@ def verify(self, module, expect):
|
|||
fxn = lambda: module
|
||||
wrapped = util.set_package(fxn)
|
||||
wrapped()
|
||||
self.assert_(hasattr(module, '__package__'))
|
||||
self.assertTrue(hasattr(module, '__package__'))
|
||||
self.assertEqual(expect, module.__package__)
|
||||
|
||||
def test_top_level(self):
|
||||
|
|
|
@ -8,12 +8,12 @@
|
|||
class TestDecode(TestCase):
|
||||
def test_decimal(self):
|
||||
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'))
|
||||
|
||||
def test_float(self):
|
||||
rval = json.loads('1', parse_int=float)
|
||||
self.assert_(isinstance(rval, float))
|
||||
self.assertTrue(isinstance(rval, float))
|
||||
self.assertEquals(rval, 1.0)
|
||||
|
||||
def test_object_pairs_hook(self):
|
||||
|
|
|
@ -7,9 +7,9 @@
|
|||
class TestSpeedups(TestCase):
|
||||
def test_scanstring(self):
|
||||
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):
|
||||
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)
|
||||
|
|
|
@ -50,15 +50,15 @@ def test_read(self):
|
|||
for key, value in self.reference.items():
|
||||
self.assertEqual(d[key], value)
|
||||
knownkey = list(self.other.keys())[0]
|
||||
self.failUnlessRaises(KeyError, lambda:d[knownkey])
|
||||
self.assertRaises(KeyError, lambda:d[knownkey])
|
||||
#len
|
||||
self.assertEqual(len(p), 0)
|
||||
self.assertEqual(len(d), len(self.reference))
|
||||
#__contains__
|
||||
for k in self.reference:
|
||||
self.assert_(k in d)
|
||||
self.assertTrue(k in d)
|
||||
for k in self.other:
|
||||
self.failIf(k in d)
|
||||
self.assertFalse(k in d)
|
||||
#cmp
|
||||
self.assertEqual(p, p)
|
||||
self.assertEqual(d, d)
|
||||
|
@ -69,10 +69,10 @@ def test_read(self):
|
|||
if not d: self.fail("Full mapping must compare to True")
|
||||
# keys(), items(), iterkeys() ...
|
||||
def check_iterandlist(iter, lst, ref):
|
||||
self.assert_(hasattr(iter, '__next__'))
|
||||
self.assert_(hasattr(iter, '__iter__'))
|
||||
self.assertTrue(hasattr(iter, '__next__'))
|
||||
self.assertTrue(hasattr(iter, '__iter__'))
|
||||
x = list(iter)
|
||||
self.assert_(set(x)==set(lst)==set(ref))
|
||||
self.assertTrue(set(x)==set(lst)==set(ref))
|
||||
check_iterandlist(iter(d.keys()), list(d.keys()),
|
||||
self.reference.keys())
|
||||
check_iterandlist(iter(d), list(d.keys()), self.reference.keys())
|
||||
|
@ -85,7 +85,7 @@ def check_iterandlist(iter, lst, ref):
|
|||
knownkey, knownvalue = next(iter(self.other.items()))
|
||||
self.assertEqual(d.get(key, knownvalue), value)
|
||||
self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
|
||||
self.failIf(knownkey in d)
|
||||
self.assertFalse(knownkey in d)
|
||||
|
||||
def test_write(self):
|
||||
# Test for write operations on mapping
|
||||
|
@ -96,7 +96,7 @@ def test_write(self):
|
|||
self.assertEqual(p[key], value)
|
||||
for key in self.reference.keys():
|
||||
del p[key]
|
||||
self.failUnlessRaises(KeyError, lambda:p[key])
|
||||
self.assertRaises(KeyError, lambda:p[key])
|
||||
p = self._empty_mapping()
|
||||
#update
|
||||
p.update(self.reference)
|
||||
|
@ -115,16 +115,16 @@ def test_write(self):
|
|||
self.assertEqual(d[knownkey], knownvalue)
|
||||
#pop
|
||||
self.assertEqual(d.pop(knownkey), knownvalue)
|
||||
self.failIf(knownkey in d)
|
||||
self.assertFalse(knownkey in d)
|
||||
self.assertRaises(KeyError, d.pop, knownkey)
|
||||
default = 909
|
||||
d[knownkey] = 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)
|
||||
#popitem
|
||||
key, value = d.popitem()
|
||||
self.failIf(key in d)
|
||||
self.assertFalse(key in d)
|
||||
self.assertEqual(value, self.reference[key])
|
||||
p=self._empty_mapping()
|
||||
self.assertRaises(KeyError, p.popitem)
|
||||
|
@ -133,17 +133,17 @@ def test_constructor(self):
|
|||
self.assertEqual(self._empty_mapping(), self._empty_mapping())
|
||||
|
||||
def test_bool(self):
|
||||
self.assert_(not self._empty_mapping())
|
||||
self.assert_(self.reference)
|
||||
self.assert_(bool(self._empty_mapping()) is False)
|
||||
self.assert_(bool(self.reference) is True)
|
||||
self.assertTrue(not self._empty_mapping())
|
||||
self.assertTrue(self.reference)
|
||||
self.assertTrue(bool(self._empty_mapping()) is False)
|
||||
self.assertTrue(bool(self.reference) is True)
|
||||
|
||||
def test_keys(self):
|
||||
d = self._empty_mapping()
|
||||
self.assertEqual(list(d.keys()), [])
|
||||
d = self.reference
|
||||
self.assert_(list(self.inmapping.keys())[0] in d.keys())
|
||||
self.assert_(list(self.other.keys())[0] not in d.keys())
|
||||
self.assertTrue(list(self.inmapping.keys())[0] in d.keys())
|
||||
self.assertTrue(list(self.other.keys())[0] not in d.keys())
|
||||
self.assertRaises(TypeError, d.keys, None)
|
||||
|
||||
def test_values(self):
|
||||
|
@ -268,10 +268,10 @@ def __next__(self):
|
|||
|
||||
def test_get(self):
|
||||
d = self._empty_mapping()
|
||||
self.assert_(d.get(list(self.other.keys())[0]) is None)
|
||||
self.assertTrue(d.get(list(self.other.keys())[0]) is None)
|
||||
self.assertEqual(d.get(list(self.other.keys())[0], 3), 3)
|
||||
d = self.reference
|
||||
self.assert_(d.get(list(self.other.keys())[0]) is None)
|
||||
self.assertTrue(d.get(list(self.other.keys())[0]) is None)
|
||||
self.assertEqual(d.get(list(self.other.keys())[0], 3), 3)
|
||||
self.assertEqual(d.get(list(self.inmapping.keys())[0]),
|
||||
list(self.inmapping.values())[0])
|
||||
|
@ -304,15 +304,15 @@ def test_pop(self):
|
|||
class TestMappingProtocol(BasicTestMappingProtocol):
|
||||
def 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})
|
||||
|
||||
def test_bool(self):
|
||||
BasicTestMappingProtocol.test_bool(self)
|
||||
self.assert_(not self._empty_mapping())
|
||||
self.assert_(self._full_mapping({"x": "y"}))
|
||||
self.assert_(bool(self._empty_mapping()) is False)
|
||||
self.assert_(bool(self._full_mapping({"x": "y"})) is True)
|
||||
self.assertTrue(not self._empty_mapping())
|
||||
self.assertTrue(self._full_mapping({"x": "y"}))
|
||||
self.assertTrue(bool(self._empty_mapping()) is False)
|
||||
self.assertTrue(bool(self._full_mapping({"x": "y"})) is True)
|
||||
|
||||
def test_keys(self):
|
||||
BasicTestMappingProtocol.test_keys(self)
|
||||
|
@ -320,9 +320,9 @@ def test_keys(self):
|
|||
self.assertEqual(list(d.keys()), [])
|
||||
d = self._full_mapping({'a': 1, 'b': 2})
|
||||
k = d.keys()
|
||||
self.assert_('a' in k)
|
||||
self.assert_('b' in k)
|
||||
self.assert_('c' not in k)
|
||||
self.assertTrue('a' in k)
|
||||
self.assertTrue('b' in k)
|
||||
self.assertTrue('c' not in k)
|
||||
|
||||
def test_values(self):
|
||||
BasicTestMappingProtocol.test_values(self)
|
||||
|
@ -337,12 +337,12 @@ def test_items(self):
|
|||
|
||||
def test_contains(self):
|
||||
d = self._empty_mapping()
|
||||
self.assert_(not ('a' in d))
|
||||
self.assert_('a' not in d)
|
||||
self.assertTrue(not ('a' in d))
|
||||
self.assertTrue('a' not in d)
|
||||
d = self._full_mapping({'a': 1, 'b': 2})
|
||||
self.assert_('a' in d)
|
||||
self.assert_('b' in d)
|
||||
self.assert_('c' not in d)
|
||||
self.assertTrue('a' in d)
|
||||
self.assertTrue('b' in d)
|
||||
self.assertTrue('c' not in d)
|
||||
|
||||
self.assertRaises(TypeError, d.__contains__)
|
||||
|
||||
|
@ -421,7 +421,7 @@ def __getitem__(self, i):
|
|||
def test_fromkeys(self):
|
||||
self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
|
||||
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((4,5),0), {4:0, 5:0})
|
||||
self.assertEqual(d.fromkeys([]), {})
|
||||
|
@ -432,17 +432,17 @@ def g():
|
|||
class dictlike(self.type2test): pass
|
||||
self.assertEqual(dictlike.fromkeys('a'), {'a':None})
|
||||
self.assertEqual(dictlike().fromkeys('a'), {'a':None})
|
||||
self.assert_(dictlike.fromkeys('a').__class__ is dictlike)
|
||||
self.assert_(dictlike().fromkeys('a').__class__ is dictlike)
|
||||
self.assertTrue(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
|
||||
# self.assert_(type(dictlike.fromkeys('a')) is dictlike)
|
||||
# self.assertTrue(type(dictlike.fromkeys('a')) is dictlike)
|
||||
class mydict(self.type2test):
|
||||
def __new__(cls):
|
||||
return collections.UserDict()
|
||||
ud = mydict.fromkeys('ab')
|
||||
self.assertEqual(ud, {'a':None, 'b':None})
|
||||
# FIXME: the following won't work with UserDict, because it's an old style class
|
||||
# self.assert_(isinstance(ud, collections.UserDict))
|
||||
# self.assertTrue(isinstance(ud, collections.UserDict))
|
||||
self.assertRaises(TypeError, dict.fromkeys)
|
||||
|
||||
class Exc(Exception): pass
|
||||
|
@ -472,16 +472,16 @@ def test_copy(self):
|
|||
self.assertEqual(d.copy(), {1:1, 2:2, 3:3})
|
||||
d = self._empty_mapping()
|
||||
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)
|
||||
|
||||
def test_get(self):
|
||||
BasicTestMappingProtocol.test_get(self)
|
||||
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)
|
||||
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('a'), 1)
|
||||
self.assertEqual(d.get('a', 3), 1)
|
||||
|
@ -489,9 +489,9 @@ def test_get(self):
|
|||
def test_setdefault(self):
|
||||
BasicTestMappingProtocol.test_setdefault(self)
|
||||
d = self._empty_mapping()
|
||||
self.assert_(d.setdefault('key0') is None)
|
||||
self.assertTrue(d.setdefault('key0') is None)
|
||||
d.setdefault('key0', [])
|
||||
self.assert_(d.setdefault('key0') is None)
|
||||
self.assertTrue(d.setdefault('key0') is None)
|
||||
d.setdefault('key', []).append(3)
|
||||
self.assertEqual(d['key'][0], 3)
|
||||
d.setdefault('key', []).append(4)
|
||||
|
@ -517,9 +517,9 @@ def test_popitem(self):
|
|||
self.assertEqual(va, int(ka))
|
||||
kb, vb = tb = b.popitem()
|
||||
self.assertEqual(vb, int(kb))
|
||||
self.assert_(not(copymode < 0 and ta != tb))
|
||||
self.assert_(not a)
|
||||
self.assert_(not b)
|
||||
self.assertTrue(not(copymode < 0 and ta != tb))
|
||||
self.assertTrue(not a)
|
||||
self.assertTrue(not b)
|
||||
|
||||
def test_pop(self):
|
||||
BasicTestMappingProtocol.test_pop(self)
|
||||
|
@ -577,7 +577,7 @@ def __new__(cls):
|
|||
return collections.UserDict()
|
||||
ud = mydict.fromkeys('ab')
|
||||
self.assertEqual(ud, {'a':None, 'b':None})
|
||||
self.assert_(isinstance(ud, collections.UserDict))
|
||||
self.assertTrue(isinstance(ud, collections.UserDict))
|
||||
|
||||
def test_pop(self):
|
||||
TestMappingProtocol.test_pop(self)
|
||||
|
|
|
@ -449,7 +449,7 @@ def test_recursive_list(self):
|
|||
s = self.dumps(l, proto)
|
||||
x = self.loads(s)
|
||||
self.assertEqual(len(x), 1)
|
||||
self.assert_(x is x[0])
|
||||
self.assertTrue(x is x[0])
|
||||
|
||||
def test_recursive_tuple(self):
|
||||
t = ([],)
|
||||
|
@ -459,7 +459,7 @@ def test_recursive_tuple(self):
|
|||
x = self.loads(s)
|
||||
self.assertEqual(len(x), 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):
|
||||
d = {}
|
||||
|
@ -468,7 +468,7 @@ def test_recursive_dict(self):
|
|||
s = self.dumps(d, proto)
|
||||
x = self.loads(s)
|
||||
self.assertEqual(list(x.keys()), [1])
|
||||
self.assert_(x[1] is x)
|
||||
self.assertTrue(x[1] is x)
|
||||
|
||||
def test_recursive_inst(self):
|
||||
i = C()
|
||||
|
@ -477,7 +477,7 @@ def test_recursive_inst(self):
|
|||
s = self.dumps(i, 2)
|
||||
x = self.loads(s)
|
||||
self.assertEqual(dir(x), dir(i))
|
||||
self.assert_(x.attr is x)
|
||||
self.assertTrue(x.attr is x)
|
||||
|
||||
def test_recursive_multi(self):
|
||||
l = []
|
||||
|
@ -491,7 +491,7 @@ def test_recursive_multi(self):
|
|||
self.assertEqual(len(x), 1)
|
||||
self.assertEqual(dir(x[0]), dir(i))
|
||||
self.assertEqual(list(x[0].attr.keys()), [1])
|
||||
self.assert_(x[0].attr[1] is x)
|
||||
self.assertTrue(x[0].attr[1] is x)
|
||||
|
||||
def test_get(self):
|
||||
self.assertRaises(KeyError, self.loads, b'g0\np0')
|
||||
|
@ -639,7 +639,7 @@ def test_proto(self):
|
|||
try:
|
||||
self.loads(badpickle)
|
||||
except ValueError as detail:
|
||||
self.failUnless(str(detail).startswith(
|
||||
self.assertTrue(str(detail).startswith(
|
||||
"unsupported pickle protocol"))
|
||||
else:
|
||||
self.fail("expected bad protocol number to raise ValueError")
|
||||
|
@ -720,7 +720,7 @@ def test_singletons(self):
|
|||
for x in None, False, True:
|
||||
s = self.dumps(x, proto)
|
||||
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]
|
||||
self.assertEqual(opcode_in_pickle(expected, s), True)
|
||||
|
||||
|
@ -770,8 +770,8 @@ def produce_global_ext(self, extcode, opcode):
|
|||
|
||||
# Dump using protocol 1 for comparison.
|
||||
s1 = self.dumps(x, 1)
|
||||
self.assert_(__name__.encode("utf-8") in s1)
|
||||
self.assert_(b"MyList" in s1)
|
||||
self.assertTrue(__name__.encode("utf-8") in s1)
|
||||
self.assertTrue(b"MyList" in s1)
|
||||
self.assertEqual(opcode_in_pickle(opcode, s1), False)
|
||||
|
||||
y = self.loads(s1)
|
||||
|
@ -780,8 +780,8 @@ def produce_global_ext(self, extcode, opcode):
|
|||
|
||||
# Dump using protocol 2 for test.
|
||||
s2 = self.dumps(x, 2)
|
||||
self.assert_(__name__.encode("utf-8") not in s2)
|
||||
self.assert_(b"MyList" not in s2)
|
||||
self.assertTrue(__name__.encode("utf-8") not in s2)
|
||||
self.assertTrue(b"MyList" not in s2)
|
||||
self.assertEqual(opcode_in_pickle(opcode, s2), True, repr(s2))
|
||||
|
||||
y = self.loads(s2)
|
||||
|
@ -825,7 +825,7 @@ def test_list_chunking(self):
|
|||
if proto == 0:
|
||||
self.assertEqual(num_appends, 0)
|
||||
else:
|
||||
self.failUnless(num_appends >= 2)
|
||||
self.assertTrue(num_appends >= 2)
|
||||
|
||||
def test_dict_chunking(self):
|
||||
n = 10 # too small to chunk
|
||||
|
@ -848,7 +848,7 @@ def test_dict_chunking(self):
|
|||
if proto == 0:
|
||||
self.assertEqual(num_setitems, 0)
|
||||
else:
|
||||
self.failUnless(num_setitems >= 2)
|
||||
self.assertTrue(num_setitems >= 2)
|
||||
|
||||
def test_simple_newobj(self):
|
||||
x = object.__new__(SimpleNewObj) # avoid __init__
|
||||
|
|
|
@ -17,7 +17,7 @@ def check_all(self, modname):
|
|||
# Silent fail here seems the best route since some modules
|
||||
# may not be available in all environments.
|
||||
return
|
||||
self.failUnless(hasattr(sys.modules[modname], "__all__"),
|
||||
self.assertTrue(hasattr(sys.modules[modname], "__all__"),
|
||||
"%s has no __all__ attribute" % modname)
|
||||
names = {}
|
||||
exec("from %s import *" % modname, names)
|
||||
|
|
|
@ -15,7 +15,7 @@ def test_names(self):
|
|||
for name in dir(__future__):
|
||||
obj = getattr(__future__, name, None)
|
||||
if obj is not None and isinstance(obj, __future__._Feature):
|
||||
self.assert_(
|
||||
self.assertTrue(
|
||||
name in given_feature_names,
|
||||
"%r should have been in all_feature_names" % name
|
||||
)
|
||||
|
@ -30,7 +30,7 @@ def test_attributes(self):
|
|||
optional = value.getOptionalRelease()
|
||||
mandatory = value.getMandatoryRelease()
|
||||
|
||||
a = self.assert_
|
||||
a = self.assertTrue
|
||||
e = self.assertEqual
|
||||
def check(t, name):
|
||||
a(isinstance(t, tuple), "%s isn't tuple" % name)
|
||||
|
|
|
@ -42,23 +42,23 @@ def foo(self): pass # abstract
|
|||
def bar(self): pass # concrete
|
||||
self.assertEqual(C.__abstractmethods__, {"foo"})
|
||||
self.assertRaises(TypeError, C) # because foo is abstract
|
||||
self.assert_(isabstract(C))
|
||||
self.assertTrue(isabstract(C))
|
||||
class D(C):
|
||||
def bar(self): pass # concrete override of concrete
|
||||
self.assertEqual(D.__abstractmethods__, {"foo"})
|
||||
self.assertRaises(TypeError, D) # because foo is still abstract
|
||||
self.assert_(isabstract(D))
|
||||
self.assertTrue(isabstract(D))
|
||||
class E(D):
|
||||
def foo(self): pass
|
||||
self.assertEqual(E.__abstractmethods__, set())
|
||||
E() # now foo is concrete, too
|
||||
self.failIf(isabstract(E))
|
||||
self.assertFalse(isabstract(E))
|
||||
class F(E):
|
||||
@abstractthing
|
||||
def bar(self): pass # abstract override of concrete
|
||||
self.assertEqual(F.__abstractmethods__, {"bar"})
|
||||
self.assertRaises(TypeError, F) # because bar is abstract now
|
||||
self.assert_(isabstract(F))
|
||||
self.assertTrue(isabstract(F))
|
||||
|
||||
def test_subclass_oldstyle_class(self):
|
||||
class A:
|
||||
|
@ -142,41 +142,41 @@ class C(A):
|
|||
def test_registration_transitiveness(self):
|
||||
class A(metaclass=abc.ABCMeta):
|
||||
pass
|
||||
self.failUnless(issubclass(A, A))
|
||||
self.failUnless(issubclass(A, (A,)))
|
||||
self.assertTrue(issubclass(A, A))
|
||||
self.assertTrue(issubclass(A, (A,)))
|
||||
class B(metaclass=abc.ABCMeta):
|
||||
pass
|
||||
self.failIf(issubclass(A, B))
|
||||
self.failIf(issubclass(A, (B,)))
|
||||
self.failIf(issubclass(B, A))
|
||||
self.failIf(issubclass(B, (A,)))
|
||||
self.assertFalse(issubclass(A, B))
|
||||
self.assertFalse(issubclass(A, (B,)))
|
||||
self.assertFalse(issubclass(B, A))
|
||||
self.assertFalse(issubclass(B, (A,)))
|
||||
class C(metaclass=abc.ABCMeta):
|
||||
pass
|
||||
A.register(B)
|
||||
class B1(B):
|
||||
pass
|
||||
self.failUnless(issubclass(B1, A))
|
||||
self.failUnless(issubclass(B1, (A,)))
|
||||
self.assertTrue(issubclass(B1, A))
|
||||
self.assertTrue(issubclass(B1, (A,)))
|
||||
class C1(C):
|
||||
pass
|
||||
B1.register(C1)
|
||||
self.failIf(issubclass(C, B))
|
||||
self.failIf(issubclass(C, (B,)))
|
||||
self.failIf(issubclass(C, B1))
|
||||
self.failIf(issubclass(C, (B1,)))
|
||||
self.failUnless(issubclass(C1, A))
|
||||
self.failUnless(issubclass(C1, (A,)))
|
||||
self.failUnless(issubclass(C1, B))
|
||||
self.failUnless(issubclass(C1, (B,)))
|
||||
self.failUnless(issubclass(C1, B1))
|
||||
self.failUnless(issubclass(C1, (B1,)))
|
||||
self.assertFalse(issubclass(C, B))
|
||||
self.assertFalse(issubclass(C, (B,)))
|
||||
self.assertFalse(issubclass(C, B1))
|
||||
self.assertFalse(issubclass(C, (B1,)))
|
||||
self.assertTrue(issubclass(C1, A))
|
||||
self.assertTrue(issubclass(C1, (A,)))
|
||||
self.assertTrue(issubclass(C1, B))
|
||||
self.assertTrue(issubclass(C1, (B,)))
|
||||
self.assertTrue(issubclass(C1, B1))
|
||||
self.assertTrue(issubclass(C1, (B1,)))
|
||||
C1.register(int)
|
||||
class MyInt(int):
|
||||
pass
|
||||
self.failUnless(issubclass(MyInt, A))
|
||||
self.failUnless(issubclass(MyInt, (A,)))
|
||||
self.failUnless(isinstance(42, A))
|
||||
self.failUnless(isinstance(42, (A,)))
|
||||
self.assertTrue(issubclass(MyInt, A))
|
||||
self.assertTrue(issubclass(MyInt, (A,)))
|
||||
self.assertTrue(isinstance(42, A))
|
||||
self.assertTrue(isinstance(42, (A,)))
|
||||
|
||||
def test_all_new_methods_are_called(self):
|
||||
class A(metaclass=abc.ABCMeta):
|
||||
|
|
|
@ -9,8 +9,8 @@
|
|||
|
||||
class TestNumbers(unittest.TestCase):
|
||||
def test_int(self):
|
||||
self.failUnless(issubclass(int, Integral))
|
||||
self.failUnless(issubclass(int, Complex))
|
||||
self.assertTrue(issubclass(int, Integral))
|
||||
self.assertTrue(issubclass(int, Complex))
|
||||
|
||||
self.assertEqual(7, int(7).real)
|
||||
self.assertEqual(0, int(7).imag)
|
||||
|
@ -19,16 +19,16 @@ def test_int(self):
|
|||
self.assertEqual(1, int(7).denominator)
|
||||
|
||||
def test_float(self):
|
||||
self.failIf(issubclass(float, Rational))
|
||||
self.failUnless(issubclass(float, Real))
|
||||
self.assertFalse(issubclass(float, Rational))
|
||||
self.assertTrue(issubclass(float, Real))
|
||||
|
||||
self.assertEqual(7.3, float(7.3).real)
|
||||
self.assertEqual(0, float(7.3).imag)
|
||||
self.assertEqual(7.3, float(7.3).conjugate())
|
||||
|
||||
def test_complex(self):
|
||||
self.failIf(issubclass(complex, Real))
|
||||
self.failUnless(issubclass(complex, Complex))
|
||||
self.assertFalse(issubclass(complex, Real))
|
||||
self.assertTrue(issubclass(complex, Complex))
|
||||
|
||||
c1, c2 = complex(3, 2), complex(4,1)
|
||||
# XXX: This is not ideal, but see the comment in math_trunc().
|
||||
|
|
|
@ -49,7 +49,7 @@ def badtypecode(self):
|
|||
def test_constructor(self):
|
||||
a = array.array(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)
|
||||
|
||||
def test_len(self):
|
||||
|
@ -64,10 +64,10 @@ def test_buffer_info(self):
|
|||
a = array.array(self.typecode, self.example)
|
||||
self.assertRaises(TypeError, a.buffer_info, 42)
|
||||
bi = a.buffer_info()
|
||||
self.assert_(isinstance(bi, tuple))
|
||||
self.assertTrue(isinstance(bi, tuple))
|
||||
self.assertEqual(len(bi), 2)
|
||||
self.assert_(isinstance(bi[0], int))
|
||||
self.assert_(isinstance(bi[1], int))
|
||||
self.assertTrue(isinstance(bi[0], int))
|
||||
self.assertTrue(isinstance(bi[1], int))
|
||||
self.assertEqual(bi[1], len(a))
|
||||
|
||||
def test_byteswap(self):
|
||||
|
@ -216,39 +216,39 @@ def test_str(self):
|
|||
|
||||
def test_cmp(self):
|
||||
a = array.array(self.typecode, self.example)
|
||||
self.assert_((a == 42) is False)
|
||||
self.assert_((a != 42) is True)
|
||||
self.assertTrue((a == 42) is False)
|
||||
self.assertTrue((a != 42) is True)
|
||||
|
||||
self.assert_((a == a) is True)
|
||||
self.assert_((a != a) is False)
|
||||
self.assert_((a < a) is False)
|
||||
self.assert_((a <= a) is True)
|
||||
self.assert_((a > a) is False)
|
||||
self.assert_((a >= a) is True)
|
||||
self.assertTrue((a == a) is True)
|
||||
self.assertTrue((a != a) is False)
|
||||
self.assertTrue((a < a) is False)
|
||||
self.assertTrue((a <= a) is True)
|
||||
self.assertTrue((a > a) is False)
|
||||
self.assertTrue((a >= a) is True)
|
||||
|
||||
al = array.array(self.typecode, self.smallerexample)
|
||||
ab = array.array(self.typecode, self.biggerexample)
|
||||
|
||||
self.assert_((a == 2*a) is False)
|
||||
self.assert_((a != 2*a) is True)
|
||||
self.assert_((a < 2*a) is True)
|
||||
self.assert_((a <= 2*a) is True)
|
||||
self.assert_((a > 2*a) is False)
|
||||
self.assert_((a >= 2*a) is False)
|
||||
self.assertTrue((a == 2*a) is False)
|
||||
self.assertTrue((a != 2*a) is True)
|
||||
self.assertTrue((a < 2*a) is True)
|
||||
self.assertTrue((a <= 2*a) is True)
|
||||
self.assertTrue((a > 2*a) is False)
|
||||
self.assertTrue((a >= 2*a) is False)
|
||||
|
||||
self.assert_((a == al) is False)
|
||||
self.assert_((a != al) is True)
|
||||
self.assert_((a < al) is False)
|
||||
self.assert_((a <= al) is False)
|
||||
self.assert_((a > al) is True)
|
||||
self.assert_((a >= al) is True)
|
||||
self.assertTrue((a == al) is False)
|
||||
self.assertTrue((a != al) is True)
|
||||
self.assertTrue((a < al) is False)
|
||||
self.assertTrue((a <= al) is False)
|
||||
self.assertTrue((a > al) is True)
|
||||
self.assertTrue((a >= al) is True)
|
||||
|
||||
self.assert_((a == ab) is False)
|
||||
self.assert_((a != ab) is True)
|
||||
self.assert_((a < ab) is True)
|
||||
self.assert_((a <= ab) is True)
|
||||
self.assert_((a > ab) is False)
|
||||
self.assert_((a >= ab) is False)
|
||||
self.assertTrue((a == ab) is False)
|
||||
self.assertTrue((a != ab) is True)
|
||||
self.assertTrue((a < ab) is True)
|
||||
self.assertTrue((a <= ab) is True)
|
||||
self.assertTrue((a > ab) is False)
|
||||
self.assertTrue((a >= ab) is False)
|
||||
|
||||
def test_add(self):
|
||||
a = array.array(self.typecode, self.example) \
|
||||
|
@ -267,7 +267,7 @@ def test_iadd(self):
|
|||
a = array.array(self.typecode, self.example[::-1])
|
||||
b = a
|
||||
a += array.array(self.typecode, 2*self.example)
|
||||
self.assert_(a is b)
|
||||
self.assertTrue(a is b)
|
||||
self.assertEqual(
|
||||
a,
|
||||
array.array(self.typecode, self.example[::-1]+2*self.example)
|
||||
|
@ -310,22 +310,22 @@ def test_imul(self):
|
|||
b = a
|
||||
|
||||
a *= 5
|
||||
self.assert_(a is b)
|
||||
self.assertTrue(a is b)
|
||||
self.assertEqual(
|
||||
a,
|
||||
array.array(self.typecode, 5*self.example)
|
||||
)
|
||||
|
||||
a *= 0
|
||||
self.assert_(a is b)
|
||||
self.assertTrue(a is b)
|
||||
self.assertEqual(a, array.array(self.typecode))
|
||||
|
||||
a *= 1000
|
||||
self.assert_(a is b)
|
||||
self.assertTrue(a is b)
|
||||
self.assertEqual(a, array.array(self.typecode))
|
||||
|
||||
a *= -1
|
||||
self.assert_(a is b)
|
||||
self.assertTrue(a is b)
|
||||
self.assertEqual(a, array.array(self.typecode))
|
||||
|
||||
a = array.array(self.typecode, self.example)
|
||||
|
|
|
@ -116,20 +116,20 @@ def to_tuple(t):
|
|||
|
||||
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:
|
||||
return
|
||||
if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):
|
||||
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)
|
||||
for name in ast_node._fields:
|
||||
value = getattr(ast_node, name)
|
||||
if isinstance(value, list):
|
||||
for child in value:
|
||||
self._assert_order(child, parent_pos)
|
||||
self._assertTrueorder(child, parent_pos)
|
||||
elif value is not None:
|
||||
self._assert_order(value, parent_pos)
|
||||
self._assertTrueorder(value, parent_pos)
|
||||
|
||||
def test_snippets(self):
|
||||
for input, output, kind in ((exec_tests, exec_results, "exec"),
|
||||
|
@ -138,7 +138,7 @@ def test_snippets(self):
|
|||
for i, o in zip(input, output):
|
||||
ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
|
||||
self.assertEquals(to_tuple(ast_tree), o)
|
||||
self._assert_order(ast_tree, (0, 0))
|
||||
self._assertTrueorder(ast_tree, (0, 0))
|
||||
|
||||
def test_slice(self):
|
||||
slc = ast.parse("x[::]").body[0].value.slice
|
||||
|
|
|
@ -60,7 +60,7 @@ def testSequences(self):
|
|||
y[1:2] += [1]
|
||||
|
||||
self.assertEquals(x, [1, 2, 1, 2, 3])
|
||||
self.assert_(x is y)
|
||||
self.assertTrue(x is y)
|
||||
|
||||
def testCustomMethods1(self):
|
||||
|
||||
|
@ -85,23 +85,23 @@ def __iadd__(self, val):
|
|||
y = x
|
||||
x += 10
|
||||
|
||||
self.assert_(isinstance(x, aug_test))
|
||||
self.assert_(y is not x)
|
||||
self.assertTrue(isinstance(x, aug_test))
|
||||
self.assertTrue(y is not x)
|
||||
self.assertEquals(x.val, 11)
|
||||
|
||||
x = aug_test2(2)
|
||||
y = x
|
||||
x += 10
|
||||
|
||||
self.assert_(y is x)
|
||||
self.assertTrue(y is x)
|
||||
self.assertEquals(x.val, 12)
|
||||
|
||||
x = aug_test3(3)
|
||||
y = x
|
||||
x += 10
|
||||
|
||||
self.assert_(isinstance(x, aug_test3))
|
||||
self.assert_(y is not x)
|
||||
self.assertTrue(isinstance(x, aug_test3))
|
||||
self.assertTrue(y is not x)
|
||||
self.assertEquals(x.val, 13)
|
||||
|
||||
|
||||
|
|
|
@ -204,7 +204,7 @@ def test_b16decode(self):
|
|||
self.assertRaises(TypeError, base64.b16decode, "")
|
||||
|
||||
def test_ErrorHeritage(self):
|
||||
self.assert_(issubclass(binascii.Error, ValueError))
|
||||
self.assertTrue(issubclass(binascii.Error, ValueError))
|
||||
|
||||
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue