mirror of
https://github.com/python/cpython.git
synced 2025-10-31 21:51:50 +00:00
e63415ead8
d1 == d2 and d1 != d2 now work even if the keys and values in d1 and d2 don't support comparisons other than ==, and testing dicts for equality is faster now (especially when inequality obtains).
261 lines
7 KiB
Python
261 lines
7 KiB
Python
# Tests for rich comparisons
|
|
|
|
from test_support import TestFailed, verify, verbose
|
|
|
|
class Number:
|
|
|
|
def __init__(self, x):
|
|
self.x = x
|
|
|
|
def __lt__(self, other):
|
|
return self.x < other
|
|
|
|
def __le__(self, other):
|
|
return self.x <= other
|
|
|
|
def __eq__(self, other):
|
|
return self.x == other
|
|
|
|
def __ne__(self, other):
|
|
return self.x != other
|
|
|
|
def __gt__(self, other):
|
|
return self.x > other
|
|
|
|
def __ge__(self, other):
|
|
return self.x >= other
|
|
|
|
def __cmp__(self, other):
|
|
raise TestFailed, "Number.__cmp__() should not be called"
|
|
|
|
def __repr__(self):
|
|
return "Number(%s)" % repr(self.x)
|
|
|
|
class Vector:
|
|
|
|
def __init__(self, data):
|
|
self.data = data
|
|
|
|
def __len__(self):
|
|
return len(self.data)
|
|
|
|
def __getitem__(self, i):
|
|
return self.data[i]
|
|
|
|
def __setitem__(self, i, v):
|
|
self.data[i] = v
|
|
|
|
def __hash__(self):
|
|
raise TypeError, "Vectors cannot be hashed"
|
|
|
|
def __nonzero__(self):
|
|
raise TypeError, "Vectors cannot be used in Boolean contexts"
|
|
|
|
def __cmp__(self, other):
|
|
raise TestFailed, "Vector.__cmp__() should not be called"
|
|
|
|
def __repr__(self):
|
|
return "Vector(%s)" % repr(self.data)
|
|
|
|
def __lt__(self, other):
|
|
return Vector([a < b for a, b in zip(self.data, self.__cast(other))])
|
|
|
|
def __le__(self, other):
|
|
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
|
|
|
|
def __eq__(self, other):
|
|
return Vector([a == b for a, b in zip(self.data, self.__cast(other))])
|
|
|
|
def __ne__(self, other):
|
|
return Vector([a != b for a, b in zip(self.data, self.__cast(other))])
|
|
|
|
def __gt__(self, other):
|
|
return Vector([a > b for a, b in zip(self.data, self.__cast(other))])
|
|
|
|
def __ge__(self, other):
|
|
return Vector([a >= b for a, b in zip(self.data, self.__cast(other))])
|
|
|
|
def __cast(self, other):
|
|
if isinstance(other, Vector):
|
|
other = other.data
|
|
if len(self.data) != len(other):
|
|
raise ValueError, "Cannot compare vectors of different length"
|
|
return other
|
|
|
|
operators = "<", "<=", "==", "!=", ">", ">="
|
|
opmap = {}
|
|
for op in operators:
|
|
opmap[op] = eval("lambda a, b: a %s b" % op)
|
|
|
|
def testvector():
|
|
a = Vector(range(2))
|
|
b = Vector(range(3))
|
|
for op in operators:
|
|
try:
|
|
opmap[op](a, b)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
raise TestFailed, "a %s b for different length should fail" % op
|
|
a = Vector(range(5))
|
|
b = Vector(5 * [2])
|
|
for op in operators:
|
|
print "%23s %-2s %-23s -> %s" % (a, op, b, opmap[op](a, b))
|
|
print "%23s %-2s %-23s -> %s" % (a, op, b.data, opmap[op](a, b.data))
|
|
print "%23s %-2s %-23s -> %s" % (a.data, op, b, opmap[op](a.data, b))
|
|
try:
|
|
if opmap[op](a, b):
|
|
raise TestFailed, "a %s b shouldn't be true" % op
|
|
else:
|
|
raise TestFailed, "a %s b shouldn't be false" % op
|
|
except TypeError:
|
|
pass
|
|
|
|
def testop(a, b, op):
|
|
try:
|
|
ax = a.x
|
|
except AttributeError:
|
|
ax = a
|
|
try:
|
|
bx = b.x
|
|
except AttributeError:
|
|
bx = b
|
|
opfunc = opmap[op]
|
|
realoutcome = opfunc(ax, bx)
|
|
testoutcome = opfunc(a, b)
|
|
if realoutcome != testoutcome:
|
|
print "Error for", a, op, b, ": expected", realoutcome,
|
|
print "but got", testoutcome
|
|
## else:
|
|
## print a, op, b, "-->", testoutcome # and "true" or "false"
|
|
|
|
def testit(a, b):
|
|
testop(a, b, "<")
|
|
testop(a, b, "<=")
|
|
testop(a, b, "==")
|
|
testop(a, b, "!=")
|
|
testop(a, b, ">")
|
|
testop(a, b, ">=")
|
|
|
|
def basic():
|
|
for a in range(3):
|
|
for b in range(3):
|
|
testit(Number(a), Number(b))
|
|
testit(a, Number(b))
|
|
testit(Number(a), b)
|
|
|
|
def tabulate(c1=Number, c2=Number):
|
|
for op in operators:
|
|
opfunc = opmap[op]
|
|
print
|
|
print "operator:", op
|
|
print
|
|
print "%9s" % "",
|
|
for b in range(3):
|
|
b = c2(b)
|
|
print "| %9s" % b,
|
|
print "|"
|
|
print '----------+-' * 4
|
|
for a in range(3):
|
|
a = c1(a)
|
|
print "%9s" % a,
|
|
for b in range(3):
|
|
b = c2(b)
|
|
print "| %9s" % opfunc(a, b),
|
|
print "|"
|
|
print '----------+-' * 4
|
|
print
|
|
print '*' * 50
|
|
|
|
def misbehavin():
|
|
class Misb:
|
|
def __lt__(self, other): return 0
|
|
def __gt__(self, other): return 0
|
|
def __eq__(self, other): return 0
|
|
def __le__(self, other): raise TestFailed, "This shouldn't happen"
|
|
def __ge__(self, other): raise TestFailed, "This shouldn't happen"
|
|
def __ne__(self, other): raise TestFailed, "This shouldn't happen"
|
|
def __cmp__(self, other): raise RuntimeError, "expected"
|
|
a = Misb()
|
|
b = Misb()
|
|
verify((a<b) == 0)
|
|
verify((a==b) == 0)
|
|
verify((a>b) == 0)
|
|
try:
|
|
print cmp(a, b)
|
|
except RuntimeError:
|
|
pass
|
|
else:
|
|
raise TestFailed, "cmp(Misb(), Misb()) didn't raise RuntimeError"
|
|
|
|
def recursion():
|
|
from UserList import UserList
|
|
a = UserList(); a.append(a)
|
|
b = UserList(); b.append(b)
|
|
def check(s, a=a, b=b):
|
|
if verbose:
|
|
print "check", s
|
|
try:
|
|
if not eval(s):
|
|
raise TestFailed, s + " was false but expected to be true"
|
|
except RuntimeError, msg:
|
|
raise TestFailed, str(msg)
|
|
if verbose:
|
|
print "recursion tests: a=%s, b=%s" % (a, b)
|
|
check('a==b')
|
|
check('not a!=b')
|
|
a.append(1)
|
|
if verbose:
|
|
print "recursion tests: a=%s, b=%s" % (a, b)
|
|
check('a!=b')
|
|
check('not a==b')
|
|
b.append(0)
|
|
if verbose:
|
|
print "recursion tests: a=%s, b=%s" % (a, b)
|
|
check('a!=b')
|
|
check('not a==b')
|
|
a[1] = -1
|
|
if verbose:
|
|
print "recursion tests: a=%s, b=%s" % (a, b)
|
|
check('a!=b')
|
|
check('not a==b')
|
|
if verbose: print "recursion tests ok"
|
|
|
|
def dicts():
|
|
# Verify that __eq__ and __ne__ work for dicts even if the keys and
|
|
# values don't support anything other than __eq__ and __ne__. Complex
|
|
# numbers are a fine example of that.
|
|
import random
|
|
imag1a = {}
|
|
for i in range(50):
|
|
imag1a[random.randrange(100)*1j] = random.randrange(100)*1j
|
|
items = imag1a.items()
|
|
random.shuffle(items)
|
|
imag1b = {}
|
|
for k, v in items:
|
|
imag1b[k] = v
|
|
imag2 = imag1b.copy()
|
|
imag2[k] = v + 1.0
|
|
verify(imag1a == imag1a, "imag1a == imag1a should have worked")
|
|
verify(imag1a == imag1b, "imag1a == imag1b should have worked")
|
|
verify(imag2 == imag2, "imag2 == imag2 should have worked")
|
|
verify(imag1a != imag2, "imag1a != imag2 should have worked")
|
|
for op in "<", "<=", ">", ">=":
|
|
try:
|
|
eval("imag1a %s imag2" % op)
|
|
except TypeError:
|
|
pass
|
|
else:
|
|
raise TestFailed("expected TypeError from imag1a %s imag2" % op)
|
|
|
|
def main():
|
|
basic()
|
|
tabulate()
|
|
tabulate(c1=int)
|
|
tabulate(c2=int)
|
|
testvector()
|
|
misbehavin()
|
|
recursion()
|
|
dicts()
|
|
|
|
main()
|