convert usage of fail* to assert*
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index f160286..6dc27be 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -409,12 +409,12 @@
def test_python_dicts(self):
# Testing Python subclass of dict...
- self.assert_(issubclass(dict, dict))
- self.assert_(isinstance({}, dict))
+ self.assertTrue(issubclass(dict, dict))
+ self.assertTrue(isinstance({}, dict))
d = dict()
self.assertEqual(d, {})
- self.assert_(d.__class__ is dict)
- self.assert_(isinstance(d, dict))
+ self.assertTrue(d.__class__ is dict)
+ self.assertTrue(isinstance(d, dict))
class C(dict):
state = -1
def __init__(self_local, *a, **kw):
@@ -427,13 +427,13 @@
def __getitem__(self, key):
return self.get(key, 0)
def __setitem__(self_local, key, value):
- self.assert_(isinstance(key, type(0)))
+ self.assertTrue(isinstance(key, type(0)))
dict.__setitem__(self_local, key, value)
def setstate(self, state):
self.state = state
def getstate(self):
return self.state
- self.assert_(issubclass(C, dict))
+ self.assertTrue(issubclass(C, dict))
a1 = C(12)
self.assertEqual(a1.state, 12)
a2 = C(foo=1, bar=2)
@@ -527,7 +527,7 @@
return 42
self.assertEqual(C.name, 'C')
self.assertEqual(C.bases, ())
- self.assert_('spam' in C.dict)
+ self.assertTrue('spam' in C.dict)
c = C()
self.assertEqual(c.spam(), 42)
@@ -594,7 +594,7 @@
def _set_x(self, x):
self.__x = -x
a = A()
- self.assert_(not hasattr(a, "x"))
+ self.assertTrue(not hasattr(a, "x"))
a.x = 12
self.assertEqual(a.x, 12)
self.assertEqual(a._A__x, -12)
@@ -1171,7 +1171,7 @@
class D(object):
__slots__ = ["__dict__"]
a = D()
- self.assert_(hasattr(a, "__dict__"))
+ self.assertTrue(hasattr(a, "__dict__"))
self.assertFalse(hasattr(a, "__weakref__"))
a.foo = 42
self.assertEqual(a.__dict__, {"foo": 42})
@@ -1179,7 +1179,7 @@
class W(object):
__slots__ = ["__weakref__"]
a = W()
- self.assert_(hasattr(a, "__weakref__"))
+ self.assertTrue(hasattr(a, "__weakref__"))
self.assertFalse(hasattr(a, "__dict__"))
try:
a.foo = 42
@@ -1191,16 +1191,16 @@
class C1(W, D):
__slots__ = []
a = C1()
- self.assert_(hasattr(a, "__dict__"))
- self.assert_(hasattr(a, "__weakref__"))
+ self.assertTrue(hasattr(a, "__dict__"))
+ self.assertTrue(hasattr(a, "__weakref__"))
a.foo = 42
self.assertEqual(a.__dict__, {"foo": 42})
class C2(D, W):
__slots__ = []
a = C2()
- self.assert_(hasattr(a, "__dict__"))
- self.assert_(hasattr(a, "__weakref__"))
+ self.assertTrue(hasattr(a, "__dict__"))
+ self.assertTrue(hasattr(a, "__weakref__"))
a.foo = 42
self.assertEqual(a.__dict__, {"foo": 42})
@@ -1217,7 +1217,7 @@
MyABC.register(Unrelated)
u = Unrelated()
- self.assert_(isinstance(u, MyABC))
+ self.assertTrue(isinstance(u, MyABC))
# This used to crash
self.assertRaises(TypeError, MyABC.a.__set__, u, 3)
@@ -1473,7 +1473,7 @@
class E: # *not* subclassing from C
foo = C.foo
self.assertEqual(E().foo, C.foo) # i.e., unbound
- self.assert_(repr(C.foo.__get__(C())).startswith("<bound method "))
+ self.assertTrue(repr(C.foo.__get__(C())).startswith("<bound method "))
def test_compattr(self):
# Testing computed attributes...
@@ -1664,7 +1664,7 @@
class E(object):
foo = C.foo
self.assertEqual(E().foo, C.foo) # i.e., unbound
- self.assert_(repr(C.foo.__get__(C(1))).startswith("<bound method "))
+ self.assertTrue(repr(C.foo.__get__(C(1))).startswith("<bound method "))
def test_special_method_lookup(self):
# The lookup of special methods bypasses __getattr__ and
@@ -1776,22 +1776,22 @@
raise IndexError
c1 = C()
c2 = C()
- self.assert_(not not c1) # What?
+ self.assertTrue(not not c1) # What?
self.assertNotEqual(id(c1), id(c2))
hash(c1)
hash(c2)
self.assertEqual(cmp(c1, c2), cmp(id(c1), id(c2)))
self.assertEqual(c1, c1)
- self.assert_(c1 != c2)
- self.assert_(not c1 != c1)
- self.assert_(not c1 == c2)
+ self.assertTrue(c1 != c2)
+ self.assertTrue(not c1 != c1)
+ self.assertTrue(not c1 == c2)
# Note that the module name appears in str/repr, and that varies
# depending on whether this test is run standalone or from a framework.
- self.assert_(str(c1).find('C object at ') >= 0)
+ self.assertTrue(str(c1).find('C object at ') >= 0)
self.assertEqual(str(c1), repr(c1))
- self.assert_(-1 not in c1)
+ self.assertTrue(-1 not in c1)
for i in range(10):
- self.assert_(i in c1)
+ self.assertTrue(i in c1)
self.assertFalse(10 in c1)
# Test the default behavior for dynamic classes
class D(object):
@@ -1800,22 +1800,22 @@
raise IndexError
d1 = D()
d2 = D()
- self.assert_(not not d1)
+ self.assertTrue(not not d1)
self.assertNotEqual(id(d1), id(d2))
hash(d1)
hash(d2)
self.assertEqual(cmp(d1, d2), cmp(id(d1), id(d2)))
self.assertEqual(d1, d1)
self.assertNotEqual(d1, d2)
- self.assert_(not d1 != d1)
- self.assert_(not d1 == d2)
+ self.assertTrue(not d1 != d1)
+ self.assertTrue(not d1 == d2)
# Note that the module name appears in str/repr, and that varies
# depending on whether this test is run standalone or from a framework.
- self.assert_(str(d1).find('D object at ') >= 0)
+ self.assertTrue(str(d1).find('D object at ') >= 0)
self.assertEqual(str(d1), repr(d1))
- self.assert_(-1 not in d1)
+ self.assertTrue(-1 not in d1)
for i in range(10):
- self.assert_(i in d1)
+ self.assertTrue(i in d1)
self.assertFalse(10 in d1)
# Test overridden behavior for static classes
class Proxy(object):
@@ -1841,11 +1841,11 @@
p1 = Proxy(1)
p_1 = Proxy(-1)
self.assertFalse(p0)
- self.assert_(not not p1)
+ self.assertTrue(not not p1)
self.assertEqual(hash(p0), hash(0))
self.assertEqual(p0, p0)
self.assertNotEqual(p0, p1)
- self.assert_(not p0 != p0)
+ self.assertTrue(not p0 != p0)
self.assertEqual(not p0, p1)
self.assertEqual(cmp(p0, p1), -1)
self.assertEqual(cmp(p0, p0), 0)
@@ -1855,7 +1855,7 @@
p10 = Proxy(range(10))
self.assertFalse(-1 in p10)
for i in range(10):
- self.assert_(i in p10)
+ self.assertTrue(i in p10)
self.assertFalse(10 in p10)
# Test overridden behavior for dynamic classes
class DProxy(object):
@@ -1881,7 +1881,7 @@
p1 = DProxy(1)
p_1 = DProxy(-1)
self.assertFalse(p0)
- self.assert_(not not p1)
+ self.assertTrue(not not p1)
self.assertEqual(hash(p0), hash(0))
self.assertEqual(p0, p0)
self.assertNotEqual(p0, p1)
@@ -1895,7 +1895,7 @@
p10 = DProxy(range(10))
self.assertFalse(-1 in p10)
for i in range(10):
- self.assert_(i in p10)
+ self.assertTrue(i in p10)
self.assertFalse(10 in p10)
# Safety test for __cmp__
@@ -1975,7 +1975,7 @@
try:
weakref.ref(no)
except TypeError, msg:
- self.assert_(str(msg).find("weak reference") >= 0)
+ self.assertTrue(str(msg).find("weak reference") >= 0)
else:
self.fail("weakref.ref(no) should be illegal")
class Weak(object):
@@ -2012,18 +2012,18 @@
self.assertFalse(hasattr(a, "x"))
raw = C.__dict__['x']
- self.assert_(isinstance(raw, property))
+ self.assertTrue(isinstance(raw, property))
attrs = dir(raw)
- self.assert_("__doc__" in attrs)
- self.assert_("fget" in attrs)
- self.assert_("fset" in attrs)
- self.assert_("fdel" in attrs)
+ self.assertTrue("__doc__" in attrs)
+ self.assertTrue("fget" in attrs)
+ self.assertTrue("fset" in attrs)
+ self.assertTrue("fdel" in attrs)
self.assertEqual(raw.__doc__, "I'm the x property.")
- self.assert_(raw.fget is C.__dict__['getx'])
- self.assert_(raw.fset is C.__dict__['setx'])
- self.assert_(raw.fdel is C.__dict__['delx'])
+ self.assertTrue(raw.fget is C.__dict__['getx'])
+ self.assertTrue(raw.fset is C.__dict__['setx'])
+ self.assertTrue(raw.fdel is C.__dict__['delx'])
for attr in "__doc__", "fget", "fset", "fdel":
try:
@@ -2085,7 +2085,7 @@
self.assertEqual(C.foo.__doc__, "hello")
self.assertFalse(hasattr(c, "foo"))
c.foo = -42
- self.assert_(hasattr(c, '_foo'))
+ self.assertTrue(hasattr(c, '_foo'))
self.assertEqual(c._foo, 42)
self.assertEqual(c.foo, 42)
del c.foo
@@ -2236,7 +2236,7 @@
cstuff = ['Cdata', 'Cmethod', '__doc__', '__module__']
self.assertEqual(dir(C), cstuff)
- self.assert_('im_self' in dir(C.Cmethod))
+ self.assertTrue('im_self' in dir(C.Cmethod))
c = C() # c.__doc__ is an odd thing to see here; ditto c.__module__.
self.assertEqual(dir(c), cstuff)
@@ -2244,7 +2244,7 @@
c.cdata = 2
c.cmethod = lambda self: 0
self.assertEqual(dir(c), cstuff + ['cdata', 'cmethod'])
- self.assert_('im_self' in dir(c.Cmethod))
+ self.assertTrue('im_self' in dir(c.Cmethod))
class A(C):
Adata = 1
@@ -2252,10 +2252,10 @@
astuff = ['Adata', 'Amethod'] + cstuff
self.assertEqual(dir(A), astuff)
- self.assert_('im_self' in dir(A.Amethod))
+ self.assertTrue('im_self' in dir(A.Amethod))
a = A()
self.assertEqual(dir(a), astuff)
- self.assert_('im_self' in dir(a.Amethod))
+ self.assertTrue('im_self' in dir(a.Amethod))
a.adata = 42
a.amethod = lambda self: 3
self.assertEqual(dir(a), astuff + ['adata', 'amethod'])
@@ -2274,12 +2274,12 @@
c = C()
self.assertEqual(interesting(dir(c)), cstuff)
- self.assert_('im_self' in dir(C.Cmethod))
+ self.assertTrue('im_self' in dir(C.Cmethod))
c.cdata = 2
c.cmethod = lambda self: 0
self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod'])
- self.assert_('im_self' in dir(c.Cmethod))
+ self.assertTrue('im_self' in dir(c.Cmethod))
class A(C):
Adata = 1
@@ -2287,13 +2287,13 @@
astuff = ['Adata', 'Amethod'] + cstuff
self.assertEqual(interesting(dir(A)), astuff)
- self.assert_('im_self' in dir(A.Amethod))
+ self.assertTrue('im_self' in dir(A.Amethod))
a = A()
self.assertEqual(interesting(dir(a)), astuff)
a.adata = 42
a.amethod = lambda self: 3
self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod'])
- self.assert_('im_self' in dir(a.Amethod))
+ self.assertTrue('im_self' in dir(a.Amethod))
# Try a module subclass.
import sys
@@ -2477,13 +2477,13 @@
a = hexint(12345)
self.assertEqual(a, 12345)
self.assertEqual(int(a), 12345)
- self.assert_(int(a).__class__ is int)
+ self.assertTrue(int(a).__class__ is int)
self.assertEqual(hash(a), hash(12345))
- self.assert_((+a).__class__ is int)
- self.assert_((a >> 0).__class__ is int)
- self.assert_((a << 0).__class__ is int)
- self.assert_((hexint(0) << 12).__class__ is int)
- self.assert_((hexint(0) >> 12).__class__ is int)
+ self.assertTrue((+a).__class__ is int)
+ self.assertTrue((a >> 0).__class__ is int)
+ self.assertTrue((a << 0).__class__ is int)
+ self.assertTrue((hexint(0) << 12).__class__ is int)
+ self.assertTrue((hexint(0) >> 12).__class__ is int)
class octlong(long):
__slots__ = []
@@ -2503,36 +2503,36 @@
self.assertEqual(a, 12345L)
self.assertEqual(long(a), 12345L)
self.assertEqual(hash(a), hash(12345L))
- self.assert_(long(a).__class__ is long)
- self.assert_((+a).__class__ is long)
- self.assert_((-a).__class__ is long)
- self.assert_((-octlong(0)).__class__ is long)
- self.assert_((a >> 0).__class__ is long)
- self.assert_((a << 0).__class__ is long)
- self.assert_((a - 0).__class__ is long)
- self.assert_((a * 1).__class__ is long)
- self.assert_((a ** 1).__class__ is long)
- self.assert_((a // 1).__class__ is long)
- self.assert_((1 * a).__class__ is long)
- self.assert_((a | 0).__class__ is long)
- self.assert_((a ^ 0).__class__ is long)
- self.assert_((a & -1L).__class__ is long)
- self.assert_((octlong(0) << 12).__class__ is long)
- self.assert_((octlong(0) >> 12).__class__ is long)
- self.assert_(abs(octlong(0)).__class__ is long)
+ self.assertTrue(long(a).__class__ is long)
+ self.assertTrue((+a).__class__ is long)
+ self.assertTrue((-a).__class__ is long)
+ self.assertTrue((-octlong(0)).__class__ is long)
+ self.assertTrue((a >> 0).__class__ is long)
+ self.assertTrue((a << 0).__class__ is long)
+ self.assertTrue((a - 0).__class__ is long)
+ self.assertTrue((a * 1).__class__ is long)
+ self.assertTrue((a ** 1).__class__ is long)
+ self.assertTrue((a // 1).__class__ is long)
+ self.assertTrue((1 * a).__class__ is long)
+ self.assertTrue((a | 0).__class__ is long)
+ self.assertTrue((a ^ 0).__class__ is long)
+ self.assertTrue((a & -1L).__class__ is long)
+ self.assertTrue((octlong(0) << 12).__class__ is long)
+ self.assertTrue((octlong(0) >> 12).__class__ is long)
+ self.assertTrue(abs(octlong(0)).__class__ is long)
# Because octlong overrides __add__, we can't check the absence of +0
# optimizations using octlong.
class longclone(long):
pass
a = longclone(1)
- self.assert_((a + 0).__class__ is long)
- self.assert_((0 + a).__class__ is long)
+ self.assertTrue((a + 0).__class__ is long)
+ self.assertTrue((0 + a).__class__ is long)
# Check that negative clones don't segfault
a = longclone(-1)
self.assertEqual(a.__dict__, {})
- self.assertEqual(long(a), -1) # self.assert_ PyNumber_Long() copies the sign bit
+ self.assertEqual(long(a), -1) # self.assertTrue PyNumber_Long() copies the sign bit
class precfloat(float):
__slots__ = ['prec']
@@ -2544,9 +2544,9 @@
a = precfloat(12345)
self.assertEqual(a, 12345.0)
self.assertEqual(float(a), 12345.0)
- self.assert_(float(a).__class__ is float)
+ self.assertTrue(float(a).__class__ is float)
self.assertEqual(hash(a), hash(12345.0))
- self.assert_((+a).__class__ is float)
+ self.assertTrue((+a).__class__ is float)
class madcomplex(complex):
def __repr__(self):
@@ -2594,20 +2594,20 @@
self.assertEqual(v, t)
a = madtuple((1,2,3,4,5))
self.assertEqual(tuple(a), (1,2,3,4,5))
- self.assert_(tuple(a).__class__ is tuple)
+ self.assertTrue(tuple(a).__class__ is tuple)
self.assertEqual(hash(a), hash((1,2,3,4,5)))
- self.assert_(a[:].__class__ is tuple)
- self.assert_((a * 1).__class__ is tuple)
- self.assert_((a * 0).__class__ is tuple)
- self.assert_((a + ()).__class__ is tuple)
+ self.assertTrue(a[:].__class__ is tuple)
+ self.assertTrue((a * 1).__class__ is tuple)
+ self.assertTrue((a * 0).__class__ is tuple)
+ self.assertTrue((a + ()).__class__ is tuple)
a = madtuple(())
self.assertEqual(tuple(a), ())
- self.assert_(tuple(a).__class__ is tuple)
- self.assert_((a + a).__class__ is tuple)
- self.assert_((a * 0).__class__ is tuple)
- self.assert_((a * 1).__class__ is tuple)
- self.assert_((a * 2).__class__ is tuple)
- self.assert_(a[:].__class__ is tuple)
+ self.assertTrue(tuple(a).__class__ is tuple)
+ self.assertTrue((a + a).__class__ is tuple)
+ self.assertTrue((a * 0).__class__ is tuple)
+ self.assertTrue((a * 1).__class__ is tuple)
+ self.assertTrue((a * 2).__class__ is tuple)
+ self.assertTrue(a[:].__class__ is tuple)
class madstring(str):
_rev = None
@@ -2629,51 +2629,51 @@
self.assertEqual(u, s)
s = madstring("12345")
self.assertEqual(str(s), "12345")
- self.assert_(str(s).__class__ is str)
+ self.assertTrue(str(s).__class__ is str)
base = "\x00" * 5
s = madstring(base)
self.assertEqual(s, base)
self.assertEqual(str(s), base)
- self.assert_(str(s).__class__ is str)
+ self.assertTrue(str(s).__class__ is str)
self.assertEqual(hash(s), hash(base))
self.assertEqual({s: 1}[base], 1)
self.assertEqual({base: 1}[s], 1)
- self.assert_((s + "").__class__ is str)
+ self.assertTrue((s + "").__class__ is str)
self.assertEqual(s + "", base)
- self.assert_(("" + s).__class__ is str)
+ self.assertTrue(("" + s).__class__ is str)
self.assertEqual("" + s, base)
- self.assert_((s * 0).__class__ is str)
+ self.assertTrue((s * 0).__class__ is str)
self.assertEqual(s * 0, "")
- self.assert_((s * 1).__class__ is str)
+ self.assertTrue((s * 1).__class__ is str)
self.assertEqual(s * 1, base)
- self.assert_((s * 2).__class__ is str)
+ self.assertTrue((s * 2).__class__ is str)
self.assertEqual(s * 2, base + base)
- self.assert_(s[:].__class__ is str)
+ self.assertTrue(s[:].__class__ is str)
self.assertEqual(s[:], base)
- self.assert_(s[0:0].__class__ is str)
+ self.assertTrue(s[0:0].__class__ is str)
self.assertEqual(s[0:0], "")
- self.assert_(s.strip().__class__ is str)
+ self.assertTrue(s.strip().__class__ is str)
self.assertEqual(s.strip(), base)
- self.assert_(s.lstrip().__class__ is str)
+ self.assertTrue(s.lstrip().__class__ is str)
self.assertEqual(s.lstrip(), base)
- self.assert_(s.rstrip().__class__ is str)
+ self.assertTrue(s.rstrip().__class__ is str)
self.assertEqual(s.rstrip(), base)
identitytab = ''.join([chr(i) for i in range(256)])
- self.assert_(s.translate(identitytab).__class__ is str)
+ self.assertTrue(s.translate(identitytab).__class__ is str)
self.assertEqual(s.translate(identitytab), base)
- self.assert_(s.translate(identitytab, "x").__class__ is str)
+ self.assertTrue(s.translate(identitytab, "x").__class__ is str)
self.assertEqual(s.translate(identitytab, "x"), base)
self.assertEqual(s.translate(identitytab, "\x00"), "")
- self.assert_(s.replace("x", "x").__class__ is str)
+ self.assertTrue(s.replace("x", "x").__class__ is str)
self.assertEqual(s.replace("x", "x"), base)
- self.assert_(s.ljust(len(s)).__class__ is str)
+ self.assertTrue(s.ljust(len(s)).__class__ is str)
self.assertEqual(s.ljust(len(s)), base)
- self.assert_(s.rjust(len(s)).__class__ is str)
+ self.assertTrue(s.rjust(len(s)).__class__ is str)
self.assertEqual(s.rjust(len(s)), base)
- self.assert_(s.center(len(s)).__class__ is str)
+ self.assertTrue(s.center(len(s)).__class__ is str)
self.assertEqual(s.center(len(s)), base)
- self.assert_(s.lower().__class__ is str)
+ self.assertTrue(s.lower().__class__ is str)
self.assertEqual(s.lower(), base)
class madunicode(unicode):
@@ -2692,47 +2692,47 @@
base = u"12345"
u = madunicode(base)
self.assertEqual(unicode(u), base)
- self.assert_(unicode(u).__class__ is unicode)
+ self.assertTrue(unicode(u).__class__ is unicode)
self.assertEqual(hash(u), hash(base))
self.assertEqual({u: 1}[base], 1)
self.assertEqual({base: 1}[u], 1)
- self.assert_(u.strip().__class__ is unicode)
+ self.assertTrue(u.strip().__class__ is unicode)
self.assertEqual(u.strip(), base)
- self.assert_(u.lstrip().__class__ is unicode)
+ self.assertTrue(u.lstrip().__class__ is unicode)
self.assertEqual(u.lstrip(), base)
- self.assert_(u.rstrip().__class__ is unicode)
+ self.assertTrue(u.rstrip().__class__ is unicode)
self.assertEqual(u.rstrip(), base)
- self.assert_(u.replace(u"x", u"x").__class__ is unicode)
+ self.assertTrue(u.replace(u"x", u"x").__class__ is unicode)
self.assertEqual(u.replace(u"x", u"x"), base)
- self.assert_(u.replace(u"xy", u"xy").__class__ is unicode)
+ self.assertTrue(u.replace(u"xy", u"xy").__class__ is unicode)
self.assertEqual(u.replace(u"xy", u"xy"), base)
- self.assert_(u.center(len(u)).__class__ is unicode)
+ self.assertTrue(u.center(len(u)).__class__ is unicode)
self.assertEqual(u.center(len(u)), base)
- self.assert_(u.ljust(len(u)).__class__ is unicode)
+ self.assertTrue(u.ljust(len(u)).__class__ is unicode)
self.assertEqual(u.ljust(len(u)), base)
- self.assert_(u.rjust(len(u)).__class__ is unicode)
+ self.assertTrue(u.rjust(len(u)).__class__ is unicode)
self.assertEqual(u.rjust(len(u)), base)
- self.assert_(u.lower().__class__ is unicode)
+ self.assertTrue(u.lower().__class__ is unicode)
self.assertEqual(u.lower(), base)
- self.assert_(u.upper().__class__ is unicode)
+ self.assertTrue(u.upper().__class__ is unicode)
self.assertEqual(u.upper(), base)
- self.assert_(u.capitalize().__class__ is unicode)
+ self.assertTrue(u.capitalize().__class__ is unicode)
self.assertEqual(u.capitalize(), base)
- self.assert_(u.title().__class__ is unicode)
+ self.assertTrue(u.title().__class__ is unicode)
self.assertEqual(u.title(), base)
- self.assert_((u + u"").__class__ is unicode)
+ self.assertTrue((u + u"").__class__ is unicode)
self.assertEqual(u + u"", base)
- self.assert_((u"" + u).__class__ is unicode)
+ self.assertTrue((u"" + u).__class__ is unicode)
self.assertEqual(u"" + u, base)
- self.assert_((u * 0).__class__ is unicode)
+ self.assertTrue((u * 0).__class__ is unicode)
self.assertEqual(u * 0, u"")
- self.assert_((u * 1).__class__ is unicode)
+ self.assertTrue((u * 1).__class__ is unicode)
self.assertEqual(u * 1, base)
- self.assert_((u * 2).__class__ is unicode)
+ self.assertTrue((u * 2).__class__ is unicode)
self.assertEqual(u * 2, base + base)
- self.assert_(u[:].__class__ is unicode)
+ self.assertTrue(u[:].__class__ is unicode)
self.assertEqual(u[:], base)
- self.assert_(u[0:0].__class__ is unicode)
+ self.assertTrue(u[0:0].__class__ is unicode)
self.assertEqual(u[0:0], u"")
class sublist(list):
@@ -2851,7 +2851,7 @@
self.assertEqual(d[cistr('one')], 1)
self.assertEqual(d[cistr('tWo')], 2)
self.assertEqual(d[cistr('THrEE')], 3)
- self.assert_(cistr('ONe') in d)
+ self.assertTrue(cistr('ONe') in d)
self.assertEqual(d.get(cistr('thrEE')), 3)
def test_classic_comparisons(self):
@@ -2878,12 +2878,12 @@
c = {1: c1, 2: c2, 3: c3}
for x in 1, 2, 3:
for y in 1, 2, 3:
- self.assert_(cmp(c[x], c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))
+ self.assertTrue(cmp(c[x], c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))
for op in "<", "<=", "==", "!=", ">", ">=":
- self.assert_(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),
+ self.assertTrue(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),
"x=%d, y=%d" % (x, y))
- self.assert_(cmp(c[x], y) == cmp(x, y), "x=%d, y=%d" % (x, y))
- self.assert_(cmp(x, c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))
+ self.assertTrue(cmp(c[x], y) == cmp(x, y), "x=%d, y=%d" % (x, y))
+ self.assertTrue(cmp(x, c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))
def test_rich_comparisons(self):
# Testing rich comparisons...
@@ -2956,11 +2956,11 @@
for x in 1, 2, 3:
for y in 1, 2, 3:
for op in "<", "<=", "==", "!=", ">", ">=":
- self.assert_(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),
+ self.assertTrue(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),
"x=%d, y=%d" % (x, y))
- self.assert_(eval("c[x] %s y" % op) == eval("x %s y" % op),
+ self.assertTrue(eval("c[x] %s y" % op) == eval("x %s y" % op),
"x=%d, y=%d" % (x, y))
- self.assert_(eval("x %s c[y]" % op) == eval("x %s y" % op),
+ self.assertTrue(eval("x %s c[y]" % op) == eval("x %s y" % op),
"x=%d, y=%d" % (x, y))
def test_coercions(self):
@@ -3026,9 +3026,9 @@
for cls2 in C, D, E, F:
x = cls()
x.__class__ = cls2
- self.assert_(x.__class__ is cls2)
+ self.assertTrue(x.__class__ is cls2)
x.__class__ = cls
- self.assert_(x.__class__ is cls)
+ self.assertTrue(x.__class__ is cls)
def cant(x, C):
try:
x.__class__ = C
@@ -3090,11 +3090,11 @@
x = cls()
x.a = 1
x.__class__ = cls2
- self.assert_(x.__class__ is cls2,
+ self.assertTrue(x.__class__ is cls2,
"assigning %r as __class__ for %r silently failed" % (cls2, x))
self.assertEqual(x.a, 1)
x.__class__ = cls
- self.assert_(x.__class__ is cls,
+ self.assertTrue(x.__class__ is cls,
"assigning %r as __class__ for %r silently failed" % (cls, x))
self.assertEqual(x.a, 1)
for cls in G, J, K, L, M, N, P, R, list, Int:
@@ -3264,7 +3264,7 @@
for cls in C, C1, C2:
s = p.dumps(cls, bin)
cls2 = p.loads(s)
- self.assert_(cls2 is cls)
+ self.assertTrue(cls2 is cls)
a = C1(1, 2); a.append(42); a.append(24)
b = C2("hello", "world", 42)
@@ -3294,7 +3294,7 @@
import copy
for cls in C, C1, C2:
cls2 = copy.deepcopy(cls)
- self.assert_(cls2 is cls)
+ self.assertTrue(cls2 is cls)
a = C1(1, 2); a.append(42); a.append(24)
b = C2("hello", "world", 42)
@@ -3866,8 +3866,8 @@
__slots__=()
if test_support.check_impl_detail():
self.assertEqual(C.__basicsize__, B.__basicsize__)
- self.assert_(hasattr(C, '__dict__'))
- self.assert_(hasattr(C, '__weakref__'))
+ self.assertTrue(hasattr(C, '__dict__'))
+ self.assertTrue(hasattr(C, '__weakref__'))
C().x = 2
def test_rmul(self):
@@ -4224,29 +4224,29 @@
pass
a = C()
pa = Proxy(a)
- self.assert_(isinstance(a, C)) # Baseline
- self.assert_(isinstance(pa, C)) # Test
+ self.assertTrue(isinstance(a, C)) # Baseline
+ self.assertTrue(isinstance(pa, C)) # Test
# Test with a classic subclass
class D(C):
pass
a = D()
pa = Proxy(a)
- self.assert_(isinstance(a, C)) # Baseline
- self.assert_(isinstance(pa, C)) # Test
+ self.assertTrue(isinstance(a, C)) # Baseline
+ self.assertTrue(isinstance(pa, C)) # Test
# Test with a new-style class
class C(object):
pass
a = C()
pa = Proxy(a)
- self.assert_(isinstance(a, C)) # Baseline
- self.assert_(isinstance(pa, C)) # Test
+ self.assertTrue(isinstance(a, C)) # Baseline
+ self.assertTrue(isinstance(pa, C)) # Test
# Test with a new-style subclass
class D(C):
pass
a = D()
pa = Proxy(a)
- self.assert_(isinstance(a, C)) # Baseline
- self.assert_(isinstance(pa, C)) # Test
+ self.assertTrue(isinstance(a, C)) # Baseline
+ self.assertTrue(isinstance(pa, C)) # Test
def test_proxy_super(self):
# Testing super() for a proxy object...
@@ -4373,17 +4373,17 @@
l = []
self.assertEqual(l.__add__, l.__add__)
self.assertEqual(l.__add__, [].__add__)
- self.assert_(l.__add__ != [5].__add__)
- self.assert_(l.__add__ != l.__mul__)
- self.assert_(l.__add__.__name__ == '__add__')
+ self.assertTrue(l.__add__ != [5].__add__)
+ self.assertTrue(l.__add__ != l.__mul__)
+ self.assertTrue(l.__add__.__name__ == '__add__')
if hasattr(l.__add__, '__self__'):
# CPython
- self.assert_(l.__add__.__self__ is l)
- self.assert_(l.__add__.__objclass__ is list)
+ self.assertTrue(l.__add__.__self__ is l)
+ self.assertTrue(l.__add__.__objclass__ is list)
else:
# Python implementations where [].__add__ is a normal bound method
- self.assert_(l.__add__.im_self is l)
- self.assert_(l.__add__.im_class is list)
+ self.assertTrue(l.__add__.im_self is l)
+ self.assertTrue(l.__add__.im_class is list)
self.assertEqual(l.__add__.__doc__, list.__add__.__doc__)
try:
hash(l.__add__)