Change all occurrences of verify(x == y) into vereq(x, y), since when
this type of test fails, vereq() does a better job of reporting than
verify().
Change vereq(x, y) to use "not x == y" rather than "x != y" -- it
makes a difference is some overloading tests.
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index a6d527e..25232f3 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -4,95 +4,95 @@
from copy import deepcopy
def vereq(a, b):
- if a != b:
- raise TestFailed, "%r != %r" % (a, b)
+ if not (a == b):
+ raise TestFailed, "%r == %r" % (a, b)
def testunop(a, res, expr="len(a)", meth="__len__"):
if verbose: print "checking", expr
dict = {'a': a}
- verify(eval(expr, dict) == res)
+ vereq(eval(expr, dict), res)
t = type(a)
m = getattr(t, meth)
- verify(m == t.__dict__[meth])
- verify(m(a) == res)
+ vereq(m, t.__dict__[meth])
+ vereq(m(a), res)
bm = getattr(a, meth)
- verify(bm() == res)
+ vereq(bm(), res)
def testbinop(a, b, res, expr="a+b", meth="__add__"):
if verbose: print "checking", expr
dict = {'a': a, 'b': b}
- verify(eval(expr, dict) == res)
+ vereq(eval(expr, dict), res)
t = type(a)
m = getattr(t, meth)
- verify(m == t.__dict__[meth])
- verify(m(a, b) == res)
+ vereq(m, t.__dict__[meth])
+ vereq(m(a, b), res)
bm = getattr(a, meth)
- verify(bm(b) == res)
+ vereq(bm(b), res)
def testternop(a, b, c, res, expr="a[b:c]", meth="__getslice__"):
if verbose: print "checking", expr
dict = {'a': a, 'b': b, 'c': c}
- verify(eval(expr, dict) == res)
+ vereq(eval(expr, dict), res)
t = type(a)
m = getattr(t, meth)
- verify(m == t.__dict__[meth])
- verify(m(a, b, c) == res)
+ vereq(m, t.__dict__[meth])
+ vereq(m(a, b, c), res)
bm = getattr(a, meth)
- verify(bm(b, c) == res)
+ vereq(bm(b, c), res)
def testsetop(a, b, res, stmt="a+=b", meth="__iadd__"):
if verbose: print "checking", stmt
dict = {'a': deepcopy(a), 'b': b}
exec stmt in dict
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
t = type(a)
m = getattr(t, meth)
- verify(m == t.__dict__[meth])
+ vereq(m, t.__dict__[meth])
dict['a'] = deepcopy(a)
m(dict['a'], b)
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
dict['a'] = deepcopy(a)
bm = getattr(dict['a'], meth)
bm(b)
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
def testset2op(a, b, c, res, stmt="a[b]=c", meth="__setitem__"):
if verbose: print "checking", stmt
dict = {'a': deepcopy(a), 'b': b, 'c': c}
exec stmt in dict
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
t = type(a)
m = getattr(t, meth)
- verify(m == t.__dict__[meth])
+ vereq(m, t.__dict__[meth])
dict['a'] = deepcopy(a)
m(dict['a'], b, c)
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
dict['a'] = deepcopy(a)
bm = getattr(dict['a'], meth)
bm(b, c)
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
def testset3op(a, b, c, d, res, stmt="a[b:c]=d", meth="__setslice__"):
if verbose: print "checking", stmt
dict = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d}
exec stmt in dict
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
t = type(a)
m = getattr(t, meth)
- verify(m == t.__dict__[meth])
+ vereq(m, t.__dict__[meth])
dict['a'] = deepcopy(a)
m(dict['a'], b, c, d)
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
dict['a'] = deepcopy(a)
bm = getattr(dict['a'], meth)
bm(b, c, d)
- verify(dict['a'] == res)
+ vereq(dict['a'], res)
def class_docstrings():
class Classic:
"A classic docstring."
- verify(Classic.__doc__ == "A classic docstring.")
- verify(Classic.__dict__['__doc__'] == "A classic docstring.")
+ vereq(Classic.__doc__, "A classic docstring.")
+ vereq(Classic.__dict__['__doc__'], "A classic docstring.")
class Classic2:
pass
@@ -101,8 +101,8 @@
class NewStatic(object):
"Another docstring."
__dynamic__ = 0
- verify(NewStatic.__doc__ == "Another docstring.")
- verify(NewStatic.__dict__['__doc__'] == "Another docstring.")
+ vereq(NewStatic.__doc__, "Another docstring.")
+ vereq(NewStatic.__dict__['__doc__'], "Another docstring.")
class NewStatic2(object):
__dynamic__ = 0
@@ -112,8 +112,8 @@
class NewDynamic(object):
"Another docstring."
__dynamic__ = 1
- verify(NewDynamic.__doc__ == "Another docstring.")
- verify(NewDynamic.__dict__['__doc__'] == "Another docstring.")
+ vereq(NewDynamic.__doc__, "Another docstring.")
+ vereq(NewDynamic.__dict__['__doc__'], "Another docstring.")
class NewDynamic2(object):
__dynamic__ = 1
@@ -146,30 +146,30 @@
for i in d.keys(): l1.append(i)
l = []
for i in iter(d): l.append(i)
- verify(l == l1)
+ vereq(l, l1)
l = []
for i in d.__iter__(): l.append(i)
- verify(l == l1)
+ vereq(l, l1)
l = []
for i in dictionary.__iter__(d): l.append(i)
- verify(l == l1)
+ vereq(l, l1)
d = {1:2, 3:4}
testunop(d, 2, "len(a)", "__len__")
- verify(eval(repr(d), {}) == d)
- verify(eval(d.__repr__(), {}) == d)
+ vereq(eval(repr(d), {}), d)
+ vereq(eval(d.__repr__(), {}), d)
testset2op({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c", "__setitem__")
def dict_constructor():
if verbose:
print "Testing dictionary constructor ..."
d = dictionary()
- verify(d == {})
+ vereq(d, {})
d = dictionary({})
- verify(d == {})
+ vereq(d, {})
d = dictionary(mapping={})
- verify(d == {})
+ vereq(d, {})
d = dictionary({1: 2, 'a': 'b'})
- verify(d == {1: 2, 'a': 'b'})
+ vereq(d, {1: 2, 'a': 'b'})
for badarg in 0, 0L, 0j, "0", [0], (0,):
try:
dictionary(badarg)
@@ -206,13 +206,13 @@
Mapping.keys = lambda self: self.dict.keys()
d = dictionary(mapping=Mapping())
- verify(d == Mapping.dict)
+ vereq(d, Mapping.dict)
def test_dir():
if verbose:
print "Testing dir() ..."
junk = 12
- verify(dir() == ['junk'])
+ vereq(dir(), ['junk'])
del junk
# Just make sure these don't blow up!
@@ -225,15 +225,15 @@
def Cmethod(self): pass
cstuff = ['Cdata', 'Cmethod', '__doc__', '__module__']
- verify(dir(C) == cstuff)
+ vereq(dir(C), cstuff)
verify('im_self' in dir(C.Cmethod))
c = C() # c.__doc__ is an odd thing to see here; ditto c.__module__.
- verify(dir(c) == cstuff)
+ vereq(dir(c), cstuff)
c.cdata = 2
c.cmethod = lambda self: 0
- verify(dir(c) == cstuff + ['cdata', 'cmethod'])
+ vereq(dir(c), cstuff + ['cdata', 'cmethod'])
verify('im_self' in dir(c.Cmethod))
class A(C):
@@ -241,14 +241,14 @@
def Amethod(self): pass
astuff = ['Adata', 'Amethod'] + cstuff
- verify(dir(A) == astuff)
+ vereq(dir(A), astuff)
verify('im_self' in dir(A.Amethod))
a = A()
- verify(dir(a) == astuff)
+ vereq(dir(a), astuff)
verify('im_self' in dir(a.Amethod))
a.adata = 42
a.amethod = lambda self: 3
- verify(dir(a) == astuff + ['adata', 'amethod'])
+ vereq(dir(a), astuff + ['adata', 'amethod'])
# The same, but with new-style classes. Since these have object as a
# base class, a lot more gets sucked in.
@@ -260,15 +260,15 @@
def Cmethod(self): pass
cstuff = ['Cdata', 'Cmethod']
- verify(interesting(dir(C)) == cstuff)
+ vereq(interesting(dir(C)), cstuff)
c = C()
- verify(interesting(dir(c)) == cstuff)
+ vereq(interesting(dir(c)), cstuff)
verify('im_self' in dir(C.Cmethod))
c.cdata = 2
c.cmethod = lambda self: 0
- verify(interesting(dir(c)) == cstuff + ['cdata', 'cmethod'])
+ vereq(interesting(dir(c)), cstuff + ['cdata', 'cmethod'])
verify('im_self' in dir(c.Cmethod))
class A(C):
@@ -276,13 +276,13 @@
def Amethod(self): pass
astuff = ['Adata', 'Amethod'] + cstuff
- verify(interesting(dir(A)) == astuff)
+ vereq(interesting(dir(A)), astuff)
verify('im_self' in dir(A.Amethod))
a = A()
- verify(interesting(dir(a)) == astuff)
+ vereq(interesting(dir(a)), astuff)
a.adata = 42
a.amethod = lambda self: 3
- verify(interesting(dir(a)) == astuff + ['adata', 'amethod'])
+ vereq(interesting(dir(a)), astuff + ['adata', 'amethod'])
verify('im_self' in dir(a.Amethod))
# Try a module subclass.
@@ -292,7 +292,7 @@
minstance = M()
minstance.b = 2
minstance.a = 1
- verify(dir(minstance) == ['a', 'b'])
+ vereq(dir(minstance), ['a', 'b'])
class M2(M):
def getdict(self):
@@ -302,7 +302,7 @@
m2instance = M2()
m2instance.b = 2
m2instance.a = 1
- verify(m2instance.__dict__ == "Not a dict!")
+ vereq(m2instance.__dict__, "Not a dict!")
try:
dir(m2instance)
except TypeError:
@@ -401,16 +401,16 @@
__str__ = __repr__
a = Number(3.14, prec=6)
- verify(`a` == "3.14")
- verify(a.prec == 6)
+ vereq(`a`, "3.14")
+ vereq(a.prec, 6)
a = Number(a, prec=2)
- verify(`a` == "3.1")
- verify(a.prec == 2)
+ vereq(`a`, "3.1")
+ vereq(a.prec, 2)
a = Number(234.5)
- verify(`a` == "234.5")
- verify(a.prec == 12)
+ vereq(`a`, "234.5")
+ vereq(a.prec, 12)
def spamlists():
if verbose: print "Testing spamlist operations..."
@@ -440,13 +440,13 @@
class C(spam.spamlist):
def foo(self): return 1
a = C()
- verify(a == [])
- verify(a.foo() == 1)
+ vereq(a, [])
+ vereq(a.foo(), 1)
a.append(100)
- verify(a == [100])
- verify(a.getstate() == 0)
+ vereq(a, [100])
+ vereq(a.getstate(), 0)
a.setstate(42)
- verify(a.getstate() == 42)
+ vereq(a.getstate(), 42)
def spamdicts():
if verbose: print "Testing spamdict operations..."
@@ -468,13 +468,13 @@
for i in d.keys(): l1.append(i)
l = []
for i in iter(d): l.append(i)
- verify(l == l1)
+ vereq(l, l1)
l = []
for i in d.__iter__(): l.append(i)
- verify(l == l1)
+ vereq(l, l1)
l = []
for i in type(spamdict({})).__iter__(d): l.append(i)
- verify(l == l1)
+ vereq(l, l1)
straightd = {1:2, 3:4}
spamd = spamdict(straightd)
testunop(spamd, 2, "len(a)", "__len__")
@@ -485,20 +485,20 @@
class C(spam.spamdict):
def foo(self): return 1
a = C()
- verify(a.items() == [])
- verify(a.foo() == 1)
+ vereq(a.items(), [])
+ vereq(a.foo(), 1)
a['foo'] = 'bar'
- verify(a.items() == [('foo', 'bar')])
- verify(a.getstate() == 0)
+ vereq(a.items(), [('foo', 'bar')])
+ vereq(a.getstate(), 0)
a.setstate(100)
- verify(a.getstate() == 100)
+ vereq(a.getstate(), 100)
def pydicts():
if verbose: print "Testing Python subclass of dict..."
verify(issubclass(dictionary, dictionary))
verify(isinstance({}, dictionary))
d = dictionary()
- verify(d == {})
+ vereq(d, {})
verify(d.__class__ is dictionary)
verify(isinstance(d, dictionary))
class C(dictionary):
@@ -520,21 +520,21 @@
return self.state
verify(issubclass(C, dictionary))
a1 = C(12)
- verify(a1.state == 12)
+ vereq(a1.state, 12)
a2 = C(foo=1, bar=2)
- verify(a2[1] == 'foo' and a2[2] == 'bar')
+ vereq(a2[1] == 'foo' and a2[2], 'bar')
a = C()
- verify(a.state == -1)
- verify(a.getstate() == -1)
+ vereq(a.state, -1)
+ vereq(a.getstate(), -1)
a.setstate(0)
- verify(a.state == 0)
- verify(a.getstate() == 0)
+ vereq(a.state, 0)
+ vereq(a.getstate(), 0)
a.setstate(10)
- verify(a.state == 10)
- verify(a.getstate() == 10)
- verify(a[42] == 0)
+ vereq(a.state, 10)
+ vereq(a.getstate(), 10)
+ vereq(a[42], 0)
a[42] = 24
- verify(a[42] == 24)
+ vereq(a[42], 24)
if verbose: print "pydict stress test ..."
N = 50
for i in range(N):
@@ -543,7 +543,7 @@
a[i][j] = i*j
for i in range(N):
for j in range(N):
- verify(a[i][j] == i*j)
+ vereq(a[i][j], i*j)
def pylists():
if verbose: print "Testing Python subclass of list..."
@@ -554,10 +554,10 @@
return (i, j)
a = C()
a.extend([0,1,2])
- verify(a[0] == 100)
- verify(a[1] == 101)
- verify(a[2] == 102)
- verify(a[100:200] == (100,200))
+ vereq(a[0], 100)
+ vereq(a[1], 101)
+ vereq(a[2], 102)
+ vereq(a[100:200], (100,200))
def metaclass():
if verbose: print "Testing __metaclass__..."
@@ -570,13 +570,13 @@
def setstate(self, state):
self.__state = state
a = C()
- verify(a.getstate() == 0)
+ vereq(a.getstate(), 0)
a.setstate(10)
- verify(a.getstate() == 10)
+ vereq(a.getstate(), 10)
class D:
class __metaclass__(type):
def myself(cls): return cls
- verify(D.myself() == D)
+ vereq(D.myself(), D)
d = D()
verify(d.__class__ is D)
class M1(type):
@@ -585,9 +585,9 @@
return type.__new__(cls, name, bases, dict)
class C:
__metaclass__ = M1
- verify(C.__spam__ == 1)
+ vereq(C.__spam__, 1)
c = C()
- verify(c.__spam__ == 1)
+ vereq(c.__spam__, 1)
class _instance(object):
pass
@@ -611,11 +611,11 @@
__metaclass__ = M2
def spam(self):
return 42
- verify(C.name == 'C')
- verify(C.bases == ())
+ vereq(C.name, 'C')
+ vereq(C.bases, ())
verify('spam' in C.dict)
c = C()
- verify(c.spam() == 42)
+ vereq(c.spam(), 42)
# More metaclass examples
@@ -650,11 +650,11 @@
class D(C, B):
def meth(self):
return "D" + self.__super.meth()
- verify(D().meth() == "DCBA")
+ vereq(D().meth(), "DCBA")
class E(B, C):
def meth(self):
return "E" + self.__super.meth()
- verify(E().meth() == "EBCA")
+ vereq(E().meth(), "EBCA")
class autoproperty(type):
# Automatically create property attributes when methods
@@ -685,8 +685,8 @@
a = A()
verify(not hasattr(a, "x"))
a.x = 12
- verify(a.x == 12)
- verify(a._A__x == -12)
+ vereq(a.x, 12)
+ vereq(a._A__x, -12)
class multimetaclass(autoproperty, autosuper):
# Merge of multiple cooperating metaclasses
@@ -704,7 +704,7 @@
class D(C, B):
def _get_x(self):
return "D" + self.__super._get_x()
- verify(D().x == "DCBA")
+ vereq(D().x, "DCBA")
def pymods():
if verbose: print "Testing Python subclass of module..."
@@ -727,9 +727,9 @@
a.foo = 12
x = a.foo
del a.foo
- verify(log == [("setattr", "foo", 12),
- ("getattr", "foo"),
- ("delattr", "foo")], log)
+ vereq(log, [("setattr", "foo", 12),
+ ("getattr", "foo"),
+ ("delattr", "foo")])
def multi():
if verbose: print "Testing multiple inheritance..."
@@ -741,22 +741,22 @@
def setstate(self, state):
self.__state = state
a = C()
- verify(a.getstate() == 0)
+ vereq(a.getstate(), 0)
a.setstate(10)
- verify(a.getstate() == 10)
+ vereq(a.getstate(), 10)
class D(dictionary, C):
def __init__(self):
type({}).__init__(self)
C.__init__(self)
d = D()
- verify(d.keys() == [])
+ vereq(d.keys(), [])
d["hello"] = "world"
- verify(d.items() == [("hello", "world")])
- verify(d["hello"] == "world")
- verify(d.getstate() == 0)
+ vereq(d.items(), [("hello", "world")])
+ vereq(d["hello"], "world")
+ vereq(d.getstate(), 0)
d.setstate(10)
- verify(d.getstate() == 10)
- verify(D.__mro__ == (D, dictionary, C, object))
+ vereq(d.getstate(), 10)
+ vereq(D.__mro__, (D, dictionary, C, object))
# SF bug #442833
class Node(object):
@@ -767,46 +767,47 @@
class Frag(Node, list):
def foo(self):
return "42"
- verify(Node().__int__() == 23)
- verify(int(Node()) == 23)
- verify(Frag().__int__() == 42)
- verify(int(Frag()) == 42)
+ vereq(Node().__int__(), 23)
+ vereq(int(Node()), 23)
+ vereq(Frag().__int__(), 42)
+ vereq(int(Frag()), 42)
def diamond():
if verbose: print "Testing multiple inheritance special cases..."
class A(object):
def spam(self): return "A"
- verify(A().spam() == "A")
+ vereq(A().spam(), "A")
class B(A):
def boo(self): return "B"
def spam(self): return "B"
- verify(B().spam() == "B")
- verify(B().boo() == "B")
+ vereq(B().spam(), "B")
+ vereq(B().boo(), "B")
class C(A):
def boo(self): return "C"
- verify(C().spam() == "A")
- verify(C().boo() == "C")
+ vereq(C().spam(), "A")
+ vereq(C().boo(), "C")
class D(B, C): pass
- verify(D().spam() == "B")
- verify(D().boo() == "B")
- verify(D.__mro__ == (D, B, C, A, object))
+ vereq(D().spam(), "B")
+ vereq(D().boo(), "B")
+ vereq(D.__mro__, (D, B, C, A, object))
class E(C, B): pass
- verify(E().spam() == "B")
- verify(E().boo() == "C")
- verify(E.__mro__ == (E, C, B, A, object))
+ vereq(E().spam(), "B")
+ vereq(E().boo(), "C")
+ vereq(E.__mro__, (E, C, B, A, object))
class F(D, E): pass
- verify(F().spam() == "B")
- verify(F().boo() == "B")
- verify(F.__mro__ == (F, D, E, B, C, A, object))
+ vereq(F().spam(), "B")
+ vereq(F().boo(), "B")
+ vereq(F.__mro__, (F, D, E, B, C, A, object))
class G(E, D): pass
- verify(G().spam() == "B")
- verify(G().boo() == "C")
- verify(G.__mro__ == (G, E, D, C, B, A, object))
+ vereq(G().spam(), "B")
+ vereq(G().boo(), "C")
+ vereq(G.__mro__, (G, E, D, C, B, A, object))
def objects():
if verbose: print "Testing object class..."
a = object()
- verify(a.__class__ == object == type(a))
+ vereq(a.__class__, object)
+ vereq(type(a), object)
b = object()
verify(a is not b)
verify(not hasattr(a, "foo"))
@@ -821,10 +822,10 @@
class Cdict(object):
pass
x = Cdict()
- verify(x.__dict__ == {})
+ vereq(x.__dict__, {})
x.foo = 1
- verify(x.foo == 1)
- verify(x.__dict__ == {'foo': 1})
+ vereq(x.foo, 1)
+ vereq(x.__dict__, {'foo': 1})
def slots():
if verbose: print "Testing __slots__..."
@@ -838,11 +839,11 @@
__slots__ = ['a']
x = C1()
verify(not hasattr(x, "__dict__"))
- verify(x.a == None)
+ vereq(x.a, None)
x.a = 1
- verify(x.a == 1)
+ vereq(x.a, 1)
del x.a
- verify(x.a == None)
+ vereq(x.a, None)
class C3(object):
__slots__ = ['a', 'b', 'c']
@@ -854,30 +855,30 @@
x.a = 1
x.b = 2
x.c = 3
- verify(x.a == 1)
- verify(x.b == 2)
- verify(x.c == 3)
+ vereq(x.a, 1)
+ vereq(x.b, 2)
+ vereq(x.c, 3)
def dynamics():
if verbose: print "Testing __dynamic__..."
- verify(object.__dynamic__ == 0)
- verify(list.__dynamic__ == 0)
+ vereq(object.__dynamic__, 0)
+ vereq(list.__dynamic__, 0)
class S1:
__metaclass__ = type
__dynamic__ = 0
- verify(S1.__dynamic__ == 0)
+ vereq(S1.__dynamic__, 0)
class S(object):
__dynamic__ = 0
- verify(S.__dynamic__ == 0)
+ vereq(S.__dynamic__, 0)
class D(object):
__dynamic__ = 1
- verify(D.__dynamic__ == 1)
+ vereq(D.__dynamic__, 1)
class E(D, S):
pass
- verify(E.__dynamic__ == 1)
+ vereq(E.__dynamic__, 1)
class F(S, D):
pass
- verify(F.__dynamic__ == 1)
+ vereq(F.__dynamic__, 1)
try:
S.foo = 1
except (AttributeError, TypeError):
@@ -885,14 +886,14 @@
else:
verify(0, "assignment to a static class attribute should be illegal")
D.foo = 1
- verify(D.foo == 1)
+ vereq(D.foo, 1)
# Test that dynamic attributes are inherited
- verify(E.foo == 1)
- verify(F.foo == 1)
+ vereq(E.foo, 1)
+ vereq(F.foo, 1)
class SS(D):
__dynamic__ = 0
- verify(SS.__dynamic__ == 0)
- verify(SS.foo == 1)
+ vereq(SS.__dynamic__, 0)
+ vereq(SS.foo, 1)
try:
SS.foo = 1
except (AttributeError, TypeError):
@@ -910,23 +911,23 @@
a = C()
verify(not hasattr(a, "foobar"))
C.foobar = 2
- verify(a.foobar == 2)
+ vereq(a.foobar, 2)
C.method = lambda self: 42
- verify(a.method() == 42)
+ vereq(a.method(), 42)
C.__repr__ = lambda self: "C()"
- verify(repr(a) == "C()")
+ vereq(repr(a), "C()")
C.__int__ = lambda self: 100
- verify(int(a) == 100)
- verify(a.foobar == 2)
+ vereq(int(a), 100)
+ vereq(a.foobar, 2)
verify(not hasattr(a, "spam"))
def mygetattr(self, name):
if name == "spam":
return "spam"
raise AttributeError
C.__getattr__ = mygetattr
- verify(a.spam == "spam")
+ vereq(a.spam, "spam")
a.new = 12
- verify(a.new == 12)
+ vereq(a.new, 12)
def mysetattr(self, name, value):
if name == "spam":
raise AttributeError
@@ -938,30 +939,30 @@
pass
else:
verify(0, "expected AttributeError")
- verify(a.spam == "spam")
+ vereq(a.spam, "spam")
class D(C):
pass
d = D()
d.foo = 1
- verify(d.foo == 1)
+ vereq(d.foo, 1)
# Test handling of int*seq and seq*int
class I(int):
__dynamic__ = 1
- verify("a"*I(2) == "aa")
- verify(I(2)*"a" == "aa")
- verify(2*I(3) == 6)
- verify(I(3)*2 == 6)
- verify(I(3)*I(2) == 6)
+ vereq("a"*I(2), "aa")
+ vereq(I(2)*"a", "aa")
+ vereq(2*I(3), 6)
+ vereq(I(3)*2, 6)
+ vereq(I(3)*I(2), 6)
# Test handling of long*seq and seq*long
class L(long):
__dynamic__ = 1
- verify("a"*L(2L) == "aa")
- verify(L(2L)*"a" == "aa")
- verify(2*L(3) == 6)
- verify(L(3)*2 == 6)
- verify(L(3)*L(2) == 6)
+ vereq("a"*L(2L), "aa")
+ vereq(L(2L)*"a", "aa")
+ vereq(2*L(3), 6)
+ vereq(L(3)*2, 6)
+ vereq(L(3)*L(2), 6)
# Test comparison of classes with dynamic metaclasses
class dynamicmetaclass(type):
@@ -1029,16 +1030,16 @@
def foo(*a): return a
goo = classmethod(foo)
c = C()
- verify(C.goo(1) == (C, 1))
- verify(c.goo(1) == (C, 1))
- verify(c.foo(1) == (c, 1))
+ vereq(C.goo(1), (C, 1))
+ vereq(c.goo(1), (C, 1))
+ vereq(c.foo(1), (c, 1))
class D(C):
pass
d = D()
- verify(D.goo(1) == (D, 1))
- verify(d.goo(1) == (D, 1))
- verify(d.foo(1) == (d, 1))
- verify(D.foo(d, 1) == (d, 1))
+ vereq(D.goo(1), (D, 1))
+ vereq(d.goo(1), (D, 1))
+ vereq(d.foo(1), (d, 1))
+ vereq(D.foo(d, 1), (d, 1))
def staticmethods():
if verbose: print "Testing static methods..."
@@ -1046,16 +1047,16 @@
def foo(*a): return a
goo = staticmethod(foo)
c = C()
- verify(C.goo(1) == (1,))
- verify(c.goo(1) == (1,))
- verify(c.foo(1) == (c, 1,))
+ vereq(C.goo(1), (1,))
+ vereq(c.goo(1), (1,))
+ vereq(c.foo(1), (c, 1,))
class D(C):
pass
d = D()
- verify(D.goo(1) == (1,))
- verify(d.goo(1) == (1,))
- verify(d.foo(1) == (d, 1))
- verify(D.foo(d, 1) == (d, 1))
+ vereq(D.goo(1), (1,))
+ vereq(d.goo(1), (1,))
+ vereq(d.foo(1), (d, 1))
+ vereq(D.foo(d, 1), (d, 1))
def classic():
if verbose: print "Testing classic classes..."
@@ -1063,19 +1064,19 @@
def foo(*a): return a
goo = classmethod(foo)
c = C()
- verify(C.goo(1) == (C, 1))
- verify(c.goo(1) == (C, 1))
- verify(c.foo(1) == (c, 1))
+ vereq(C.goo(1), (C, 1))
+ vereq(c.goo(1), (C, 1))
+ vereq(c.foo(1), (c, 1))
class D(C):
pass
d = D()
- verify(D.goo(1) == (D, 1))
- verify(d.goo(1) == (D, 1))
- verify(d.foo(1) == (d, 1))
- verify(D.foo(d, 1) == (d, 1))
+ vereq(D.goo(1), (D, 1))
+ vereq(d.goo(1), (D, 1))
+ vereq(d.foo(1), (d, 1))
+ vereq(D.foo(d, 1), (d, 1))
class E: # *not* subclassing from C
foo = C.foo
- verify(E().foo == C.foo) # i.e., unbound
+ vereq(E().foo, C.foo) # i.e., unbound
verify(repr(C.foo.__get__(C())).startswith("<bound method "))
def compattr():
@@ -1099,11 +1100,11 @@
self.__x = x
x = computed_attribute(__get_x, __set_x)
a = C()
- verify(a.x == 0)
- verify(a.x == 1)
+ vereq(a.x, 0)
+ vereq(a.x, 1)
a.x = 10
- verify(a.x == 10)
- verify(a.x == 11)
+ vereq(a.x, 10)
+ vereq(a.x, 11)
def newslot():
if verbose: print "Testing __new__ slot override..."
@@ -1115,12 +1116,12 @@
def __init__(self):
self.foo = self.foo + 2
a = C()
- verify(a.foo == 3)
+ vereq(a.foo, 3)
verify(a.__class__ is C)
class D(C):
pass
b = D()
- verify(b.foo == 3)
+ vereq(b.foo, 3)
verify(b.__class__ is D)
def altmro():
@@ -1133,8 +1134,9 @@
def f(self): return "C"
class D(B, C):
pass
- verify(D.mro() == [D, B, C, A, object] == list(D.__mro__))
- verify(D().f() == "C")
+ vereq(D.mro(), [D, B, C, A, object])
+ vereq(D.__mro__, (D, B, C, A, object))
+ vereq(D().f(), "C")
class PerverseMetaType(type):
def mro(cls):
L = type.mro(cls)
@@ -1142,8 +1144,8 @@
return L
class X(A,B,C,D):
__metaclass__ = PerverseMetaType
- verify(X.__mro__ == (object, A, C, B, D, X))
- verify(X().f() == "A")
+ vereq(X.__mro__, (object, A, C, B, D, X))
+ vereq(X().f(), "A")
def overloading():
if verbose: print "Testing operator overloading..."
@@ -1184,23 +1186,23 @@
self.delslice = (i, j)
a = C()
- verify(a.foo == ("getattr", "foo"))
+ vereq(a.foo, ("getattr", "foo"))
a.foo = 12
- verify(a.setattr == ("foo", 12))
+ vereq(a.setattr, ("foo", 12))
del a.foo
- verify(a.delattr == "foo")
+ vereq(a.delattr, "foo")
- verify(a[12] == ("getitem", 12))
+ vereq(a[12], ("getitem", 12))
a[12] = 21
- verify(a.setitem == (12, 21))
+ vereq(a.setitem, (12, 21))
del a[12]
- verify(a.delitem == 12)
+ vereq(a.delitem, 12)
- verify(a[0:10] == ("getslice", 0, 10))
+ vereq(a[0:10], ("getslice", 0, 10))
a[0:10] = "foo"
- verify(a.setslice == (0, 10, "foo"))
+ vereq(a.setslice, (0, 10, "foo"))
del a[0:10]
- verify(a.delslice == (0, 10))
+ vereq(a.delslice, (0, 10))
def methods():
if verbose: print "Testing methods..."
@@ -1210,17 +1212,17 @@
def foo(self):
return self.x
c1 = C(1)
- verify(c1.foo() == 1)
+ vereq(c1.foo(), 1)
class D(C):
boo = C.foo
goo = c1.foo
d2 = D(2)
- verify(d2.foo() == 2)
- verify(d2.boo() == 2)
- verify(d2.goo() == 1)
+ vereq(d2.foo(), 2)
+ vereq(d2.boo(), 2)
+ vereq(d2.goo(), 1)
class E(object):
foo = C.foo
- verify(E().foo == C.foo) # i.e., unbound
+ vereq(E().foo, C.foo) # i.e., unbound
verify(repr(C.foo.__get__(C(1))).startswith("<bound method "))
def specials():
@@ -1234,16 +1236,16 @@
c1 = C()
c2 = C()
verify(not not c1)
- verify(hash(c1) == id(c1))
- verify(cmp(c1, c2) == cmp(id(c1), id(c2)))
- verify(c1 == c1)
+ vereq(hash(c1), id(c1))
+ vereq(cmp(c1, c2), cmp(id(c1), id(c2)))
+ vereq(c1, c1)
verify(c1 != c2)
verify(not c1 != c1)
verify(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.
verify(str(c1).find('C object at ') >= 0)
- verify(str(c1) == repr(c1))
+ vereq(str(c1), repr(c1))
verify(-1 not in c1)
for i in range(10):
verify(i in c1)
@@ -1257,16 +1259,16 @@
d1 = D()
d2 = D()
verify(not not d1)
- verify(hash(d1) == id(d1))
- verify(cmp(d1, d2) == cmp(id(d1), id(d2)))
- verify(d1 == d1)
+ vereq(hash(d1), id(d1))
+ vereq(cmp(d1, d2), cmp(id(d1), id(d2)))
+ vereq(d1, d1)
verify(d1 != d2)
verify(not d1 != d1)
verify(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.
verify(str(d1).find('D object at ') >= 0)
- verify(str(d1) == repr(d1))
+ vereq(str(d1), repr(d1))
verify(-1 not in d1)
for i in range(10):
verify(i in d1)
@@ -1296,16 +1298,16 @@
p_1 = Proxy(-1)
verify(not p0)
verify(not not p1)
- verify(hash(p0) == hash(0))
- verify(p0 == p0)
+ vereq(hash(p0), hash(0))
+ vereq(p0, p0)
verify(p0 != p1)
verify(not p0 != p0)
- verify(not p0 == p1)
- verify(cmp(p0, p1) == -1)
- verify(cmp(p0, p0) == 0)
- verify(cmp(p0, p_1) == 1)
- verify(str(p0) == "Proxy:0")
- verify(repr(p0) == "Proxy(0)")
+ vereq(not p0, p1)
+ vereq(cmp(p0, p1), -1)
+ vereq(cmp(p0, p0), 0)
+ vereq(cmp(p0, p_1), 1)
+ vereq(str(p0), "Proxy:0")
+ vereq(repr(p0), "Proxy(0)")
p10 = Proxy(range(10))
verify(-1 not in p10)
for i in range(10):
@@ -1337,16 +1339,16 @@
p_1 = DProxy(-1)
verify(not p0)
verify(not not p1)
- verify(hash(p0) == hash(0))
- verify(p0 == p0)
+ vereq(hash(p0), hash(0))
+ vereq(p0, p0)
verify(p0 != p1)
verify(not p0 != p0)
- verify(not p0 == p1)
- verify(cmp(p0, p1) == -1)
- verify(cmp(p0, p0) == 0)
- verify(cmp(p0, p_1) == 1)
- verify(str(p0) == "DProxy:0")
- verify(repr(p0) == "DProxy(0)")
+ vereq(not p0, p1)
+ vereq(cmp(p0, p1), -1)
+ vereq(cmp(p0, p0), 0)
+ vereq(cmp(p0, p_1), 1)
+ vereq(str(p0), "DProxy:0")
+ vereq(repr(p0), "DProxy(0)")
p10 = DProxy(range(10))
verify(-1 not in p10)
for i in range(10):
@@ -1410,13 +1412,13 @@
a = C()
verify(not hasattr(a, "x"))
a.x = 42
- verify(a._C__x == 42)
- verify(a.x == 42)
+ vereq(a._C__x, 42)
+ vereq(a.x, 42)
del a.x
verify(not hasattr(a, "x"))
verify(not hasattr(a, "_C__x"))
C.x.__set__(a, 100)
- verify(C.x.__get__(a) == 100)
+ vereq(C.x.__get__(a), 100)
## C.x.__set__(a)
## verify(not hasattr(a, "x"))
@@ -1429,7 +1431,7 @@
verify("fset" in attrs)
verify("fdel" in attrs)
- verify(raw.__doc__ == "I'm the x property.")
+ vereq(raw.__doc__, "I'm the x property.")
verify(raw.fget is C.__dict__['getx'])
verify(raw.fset is C.__dict__['setx'])
verify(raw.fdel is C.__dict__['delx'])
@@ -1453,7 +1455,7 @@
def meth(self, a):
return "A(%r)" % a
- verify(A().meth(1) == "A(1)")
+ vereq(A().meth(1), "A(1)")
class B(A):
def __init__(self):
@@ -1461,7 +1463,7 @@
def meth(self, a):
return "B(%r)" % a + self.__super.meth(a)
- verify(B().meth(2) == "B(2)A(2)")
+ vereq(B().meth(2), "B(2)A(2)")
class C(A):
__dynamic__ = 1
@@ -1469,7 +1471,7 @@
return "C(%r)" % a + self.__super.meth(a)
C._C__super = super(C)
- verify(C().meth(3) == "C(3)A(3)")
+ vereq(C().meth(3), "C(3)A(3)")
class D(C, B):
def meth(self, a):
@@ -1487,13 +1489,13 @@
return hexint(int.__add__(self, other))
# (Note that overriding __radd__ doesn't work,
# because the int type gets first dibs.)
- verify(repr(hexint(7) + 9) == "0x10")
- verify(repr(hexint(1000) + 7) == "0x3ef")
+ vereq(repr(hexint(7) + 9), "0x10")
+ vereq(repr(hexint(1000) + 7), "0x3ef")
a = hexint(12345)
- verify(a == 12345)
- verify(int(a) == 12345)
+ vereq(a, 12345)
+ vereq(int(a), 12345)
verify(int(a).__class__ is int)
- verify(hash(a) == hash(12345))
+ vereq(hash(a), hash(12345))
verify((+a).__class__ is int)
verify((a >> 0).__class__ is int)
verify((a << 0).__class__ is int)
@@ -1510,14 +1512,14 @@
def __add__(self, other):
return self.__class__(super(octlong, self).__add__(other))
__radd__ = __add__
- verify(str(octlong(3) + 5) == "010")
+ vereq(str(octlong(3) + 5), "010")
# (Note that overriding __radd__ here only seems to work
# because the example uses a short int left argument.)
- verify(str(5 + octlong(3000)) == "05675")
+ vereq(str(5 + octlong(3000)), "05675")
a = octlong(12345)
- verify(a == 12345L)
- verify(long(a) == 12345L)
- verify(hash(a) == hash(12345L))
+ vereq(a, 12345L)
+ vereq(long(a), 12345L)
+ vereq(hash(a), hash(12345L))
verify(long(a).__class__ is long)
verify((+a).__class__ is long)
verify((-a).__class__ is long)
@@ -1551,12 +1553,12 @@
float.__init__(value)
def __repr__(self):
return "%.*g" % (self.prec, self)
- verify(repr(precfloat(1.1)) == "1.1")
+ vereq(repr(precfloat(1.1)), "1.1")
a = precfloat(12345)
- verify(a == 12345.0)
- verify(float(a) == 12345.0)
+ vereq(a, 12345.0)
+ vereq(float(a), 12345.0)
verify(float(a).__class__ is float)
- verify(hash(a) == hash(12345.0))
+ vereq(hash(a), hash(12345.0))
verify((+a).__class__ is float)
class madcomplex(complex):
@@ -1564,27 +1566,27 @@
def __repr__(self):
return "%.17gj%+.17g" % (self.imag, self.real)
a = madcomplex(-3, 4)
- verify(repr(a) == "4j-3")
+ vereq(repr(a), "4j-3")
base = complex(-3, 4)
verify(base.__class__ is complex)
- verify(a == base)
- verify(complex(a) == base)
+ vereq(a, base)
+ vereq(complex(a), base)
verify(complex(a).__class__ is complex)
a = madcomplex(a) # just trying another form of the constructor
- verify(repr(a) == "4j-3")
- verify(a == base)
- verify(complex(a) == base)
+ vereq(repr(a), "4j-3")
+ vereq(a, base)
+ vereq(complex(a), base)
verify(complex(a).__class__ is complex)
- verify(hash(a) == hash(base))
+ vereq(hash(a), hash(base))
verify((+a).__class__ is complex)
verify((a + 0).__class__ is complex)
- verify(a + 0 == base)
+ vereq(a + 0, base)
verify((a - 0).__class__ is complex)
- verify(a - 0 == base)
+ vereq(a - 0, base)
verify((a * 1).__class__ is complex)
- verify(a * 1 == base)
+ vereq(a * 1, base)
verify((a / 1).__class__ is complex)
- verify(a / 1 == base)
+ vereq(a / 1, base)
class madtuple(tuple):
_rev = None
@@ -1596,24 +1598,24 @@
self._rev = self.__class__(L)
return self._rev
a = madtuple((1,2,3,4,5,6,7,8,9,0))
- verify(a == (1,2,3,4,5,6,7,8,9,0))
- verify(a.rev() == madtuple((0,9,8,7,6,5,4,3,2,1)))
- verify(a.rev().rev() == madtuple((1,2,3,4,5,6,7,8,9,0)))
+ vereq(a, (1,2,3,4,5,6,7,8,9,0))
+ vereq(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1)))
+ vereq(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0)))
for i in range(512):
t = madtuple(range(i))
u = t.rev()
v = u.rev()
- verify(v == t)
+ vereq(v, t)
a = madtuple((1,2,3,4,5))
- verify(tuple(a) == (1,2,3,4,5))
+ vereq(tuple(a), (1,2,3,4,5))
verify(tuple(a).__class__ is tuple)
- verify(hash(a) == hash((1,2,3,4,5)))
+ vereq(hash(a), hash((1,2,3,4,5)))
verify(a[:].__class__ is tuple)
verify((a * 1).__class__ is tuple)
verify((a * 0).__class__ is tuple)
verify((a + ()).__class__ is tuple)
a = madtuple(())
- verify(tuple(a) == ())
+ vereq(tuple(a), ())
verify(tuple(a).__class__ is tuple)
verify((a + a).__class__ is tuple)
verify((a * 0).__class__ is tuple)
@@ -1631,72 +1633,72 @@
self._rev = self.__class__("".join(L))
return self._rev
s = madstring("abcdefghijklmnopqrstuvwxyz")
- verify(s == "abcdefghijklmnopqrstuvwxyz")
- verify(s.rev() == madstring("zyxwvutsrqponmlkjihgfedcba"))
- verify(s.rev().rev() == madstring("abcdefghijklmnopqrstuvwxyz"))
+ vereq(s, "abcdefghijklmnopqrstuvwxyz")
+ vereq(s.rev(), madstring("zyxwvutsrqponmlkjihgfedcba"))
+ vereq(s.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz"))
for i in range(256):
s = madstring("".join(map(chr, range(i))))
t = s.rev()
u = t.rev()
- verify(u == s)
+ vereq(u, s)
s = madstring("12345")
- verify(str(s) == "12345")
+ vereq(str(s), "12345")
verify(str(s).__class__ is str)
base = "\x00" * 5
s = madstring(base)
- verify(s == base)
- verify(str(s) == base)
+ vereq(s, base)
+ vereq(str(s), base)
verify(str(s).__class__ is str)
- verify(hash(s) == hash(base))
- verify({s: 1}[base] == 1)
- verify({base: 1}[s] == 1)
+ vereq(hash(s), hash(base))
+ vereq({s: 1}[base], 1)
+ vereq({base: 1}[s], 1)
verify((s + "").__class__ is str)
- verify(s + "" == base)
+ vereq(s + "", base)
verify(("" + s).__class__ is str)
- verify("" + s == base)
+ vereq("" + s, base)
verify((s * 0).__class__ is str)
- verify(s * 0 == "")
+ vereq(s * 0, "")
verify((s * 1).__class__ is str)
- verify(s * 1 == base)
+ vereq(s * 1, base)
verify((s * 2).__class__ is str)
- verify(s * 2 == base + base)
+ vereq(s * 2, base + base)
verify(s[:].__class__ is str)
- verify(s[:] == base)
+ vereq(s[:], base)
verify(s[0:0].__class__ is str)
- verify(s[0:0] == "")
+ vereq(s[0:0], "")
verify(s.strip().__class__ is str)
- verify(s.strip() == base)
+ vereq(s.strip(), base)
verify(s.lstrip().__class__ is str)
- verify(s.lstrip() == base)
+ vereq(s.lstrip(), base)
verify(s.rstrip().__class__ is str)
- verify(s.rstrip() == base)
+ vereq(s.rstrip(), base)
identitytab = ''.join([chr(i) for i in range(256)])
verify(s.translate(identitytab).__class__ is str)
- verify(s.translate(identitytab) == base)
+ vereq(s.translate(identitytab), base)
verify(s.translate(identitytab, "x").__class__ is str)
- verify(s.translate(identitytab, "x") == base)
- verify(s.translate(identitytab, "\x00") == "")
+ vereq(s.translate(identitytab, "x"), base)
+ vereq(s.translate(identitytab, "\x00"), "")
verify(s.replace("x", "x").__class__ is str)
- verify(s.replace("x", "x") == base)
+ vereq(s.replace("x", "x"), base)
verify(s.ljust(len(s)).__class__ is str)
- verify(s.ljust(len(s)) == base)
+ vereq(s.ljust(len(s)), base)
verify(s.rjust(len(s)).__class__ is str)
- verify(s.rjust(len(s)) == base)
+ vereq(s.rjust(len(s)), base)
verify(s.center(len(s)).__class__ is str)
- verify(s.center(len(s)) == base)
+ vereq(s.center(len(s)), base)
verify(s.lower().__class__ is str)
- verify(s.lower() == base)
+ vereq(s.lower(), base)
s = madstring("x y")
- verify(s == "x y")
+ vereq(s, "x y")
verify(intern(s).__class__ is str)
verify(intern(s) is intern("x y"))
- verify(intern(s) == "x y")
+ vereq(intern(s), "x y")
i = intern("y x")
s = madstring("y x")
- verify(s == i)
+ vereq(s, i)
verify(intern(s).__class__ is str)
verify(intern(s) is i)
@@ -1714,54 +1716,54 @@
self._rev = self.__class__(u"".join(L))
return self._rev
u = madunicode("ABCDEF")
- verify(u == u"ABCDEF")
- verify(u.rev() == madunicode(u"FEDCBA"))
- verify(u.rev().rev() == madunicode(u"ABCDEF"))
+ vereq(u, u"ABCDEF")
+ vereq(u.rev(), madunicode(u"FEDCBA"))
+ vereq(u.rev().rev(), madunicode(u"ABCDEF"))
base = u"12345"
u = madunicode(base)
- verify(unicode(u) == base)
+ vereq(unicode(u), base)
verify(unicode(u).__class__ is unicode)
- verify(hash(u) == hash(base))
- verify({u: 1}[base] == 1)
- verify({base: 1}[u] == 1)
+ vereq(hash(u), hash(base))
+ vereq({u: 1}[base], 1)
+ vereq({base: 1}[u], 1)
verify(u.strip().__class__ is unicode)
- verify(u.strip() == base)
+ vereq(u.strip(), base)
verify(u.lstrip().__class__ is unicode)
- verify(u.lstrip() == base)
+ vereq(u.lstrip(), base)
verify(u.rstrip().__class__ is unicode)
- verify(u.rstrip() == base)
+ vereq(u.rstrip(), base)
verify(u.replace(u"x", u"x").__class__ is unicode)
- verify(u.replace(u"x", u"x") == base)
+ vereq(u.replace(u"x", u"x"), base)
verify(u.replace(u"xy", u"xy").__class__ is unicode)
- verify(u.replace(u"xy", u"xy") == base)
+ vereq(u.replace(u"xy", u"xy"), base)
verify(u.center(len(u)).__class__ is unicode)
- verify(u.center(len(u)) == base)
+ vereq(u.center(len(u)), base)
verify(u.ljust(len(u)).__class__ is unicode)
- verify(u.ljust(len(u)) == base)
+ vereq(u.ljust(len(u)), base)
verify(u.rjust(len(u)).__class__ is unicode)
- verify(u.rjust(len(u)) == base)
+ vereq(u.rjust(len(u)), base)
verify(u.lower().__class__ is unicode)
- verify(u.lower() == base)
+ vereq(u.lower(), base)
verify(u.upper().__class__ is unicode)
- verify(u.upper() == base)
+ vereq(u.upper(), base)
verify(u.capitalize().__class__ is unicode)
- verify(u.capitalize() == base)
+ vereq(u.capitalize(), base)
verify(u.title().__class__ is unicode)
- verify(u.title() == base)
+ vereq(u.title(), base)
verify((u + u"").__class__ is unicode)
- verify(u + u"" == base)
+ vereq(u + u"", base)
verify((u"" + u).__class__ is unicode)
- verify(u"" + u == base)
+ vereq(u"" + u, base)
verify((u * 0).__class__ is unicode)
- verify(u * 0 == u"")
+ vereq(u * 0, u"")
verify((u * 1).__class__ is unicode)
- verify(u * 1 == base)
+ vereq(u * 1, base)
verify((u * 2).__class__ is unicode)
- verify(u * 2 == base + base)
+ vereq(u * 2, base + base)
verify(u[:].__class__ is unicode)
- verify(u[:] == base)
+ vereq(u[:], base)
verify(u[0:0].__class__ is unicode)
- verify(u[0:0] == u"")
+ vereq(u[0:0], u"")
class CountedInput(file):
"""Counts lines read by self.readline().
@@ -1795,9 +1797,9 @@
f = CountedInput(TESTFN)
for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [""]):
got = f.readline()
- verify(expected == got)
- verify(f.lineno == i)
- verify(f.ateof == (i > len(lines)))
+ vereq(expected, got)
+ vereq(f.lineno, i)
+ vereq(f.ateof, (i > len(lines)))
f.close()
finally:
try:
@@ -1813,15 +1815,15 @@
def keywords():
if verbose:
print "Testing keyword args to basic type constructors ..."
- verify(int(x=1) == 1)
- verify(float(x=2) == 2.0)
- verify(long(x=3) == 3L)
- verify(complex(imag=42, real=666) == complex(666, 42))
- verify(str(object=500) == '500')
- verify(unicode(string='abc', errors='strict') == u'abc')
- verify(tuple(sequence=range(3)) == (0, 1, 2))
- verify(list(sequence=(0, 1, 2)) == range(3))
- verify(dictionary(mapping={1: 2}) == {1: 2})
+ vereq(int(x=1), 1)
+ vereq(float(x=2), 2.0)
+ vereq(long(x=3), 3L)
+ vereq(complex(imag=42, real=666), complex(666, 42))
+ vereq(str(object=500), '500')
+ vereq(unicode(string='abc', errors='strict'), u'abc')
+ vereq(tuple(sequence=range(3)), (0, 1, 2))
+ vereq(list(sequence=(0, 1, 2)), range(3))
+ vereq(dictionary(mapping={1: 2}), {1: 2})
for constructor in (int, float, long, complex, str, unicode,
tuple, list, dictionary, file):
@@ -1896,16 +1898,16 @@
def __hash__(self):
return self.hashcode
- verify(cistr('ABC') == 'abc')
- verify('aBc' == cistr('ABC'))
- verify(str(cistr('ABC')) == 'ABC')
+ vereq(cistr('ABC'), 'abc')
+ vereq('aBc', cistr('ABC'))
+ vereq(str(cistr('ABC')), 'ABC')
d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3}
- verify(d[cistr('one')] == 1)
- verify(d[cistr('tWo')] == 2)
- verify(d[cistr('THrEE')] == 3)
+ vereq(d[cistr('one')], 1)
+ vereq(d[cistr('tWo')], 2)
+ vereq(d[cistr('THrEE')], 3)
verify(cistr('ONe') in d)
- verify(d.get(cistr('thrEE')) == 3)
+ vereq(d.get(cistr('thrEE')), 3)
def classic_comparisons():
if verbose: print "Testing classic comparisons..."
@@ -1925,7 +1927,7 @@
c1 = C(1)
c2 = C(2)
c3 = C(3)
- verify(c1 == 1)
+ vereq(c1, 1)
c = {1: c1, 2: c2, 3: c3}
for x in 1, 2, 3:
for y in 1, 2, 3:
@@ -1942,8 +1944,8 @@
class Z(complex):
__dynamic__ = 0
z = Z(1)
- verify(z == 1+0j)
- verify(1+0j == z)
+ vereq(z, 1+0j)
+ vereq(1+0j, z)
class ZZ(complex):
__dynamic__ = 0
def __eq__(self, other):
@@ -1952,8 +1954,8 @@
except:
return NotImplemented
zz = ZZ(1.0000003)
- verify(zz == 1+0j)
- verify(1+0j == zz)
+ vereq(zz, 1+0j)
+ vereq(1+0j, zz)
class classic:
pass
@@ -2003,7 +2005,7 @@
c1 = C(1)
c2 = C(2)
c3 = C(3)
- verify(c1 == 1)
+ vereq(c1, 1)
c = {1: c1, 2: c2, 3: c3}
for x in 1, 2, 3:
for y in 1, 2, 3:
@@ -2046,7 +2048,7 @@
def descrdoc():
if verbose: print "Testing descriptor doc strings..."
def check(descr, what):
- verify(descr.__doc__ == what, repr(descr.__doc__))
+ vereq(descr.__doc__, what)
check(file.closed, "flag set if the file is closed") # getset descriptor
check(file.name, "file name") # member descriptor
@@ -2170,17 +2172,17 @@
a = C()
a.foo = 12
b = copy.copy(a)
- verify(b.__dict__ == a.__dict__)
+ vereq(b.__dict__, a.__dict__)
a.bar = [1,2,3]
c = copy.copy(a)
- verify(c.bar == a.bar)
+ vereq(c.bar, a.bar)
verify(c.bar is a.bar)
d = copy.deepcopy(a)
- verify(d.__dict__ == a.__dict__)
+ vereq(d.__dict__, a.__dict__)
a.bar.append(4)
- verify(d.bar == [1,2,3])
+ vereq(d.bar, [1,2,3])
def binopoverride():
if verbose: print "Testing overrides of binary operations..."