mirror of https://github.com/python/cpython
337 lines
11 KiB
Python
337 lines
11 KiB
Python
# Tests for rich comparisons
|
|
|
|
import unittest
|
|
from test import test_support
|
|
|
|
import operator
|
|
|
|
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 test_support.TestFailed, "Number.__cmp__() should not be called"
|
|
|
|
def __repr__(self):
|
|
return "Number(%r)" % (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
|
|
|
|
__hash__ = None # Vectors cannot be hashed
|
|
|
|
def __nonzero__(self):
|
|
raise TypeError, "Vectors cannot be used in Boolean contexts"
|
|
|
|
def __cmp__(self, other):
|
|
raise test_support.TestFailed, "Vector.__cmp__() should not be called"
|
|
|
|
def __repr__(self):
|
|
return "Vector(%r)" % (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
|
|
|
|
opmap = {
|
|
"lt": (lambda a,b: a< b, operator.lt, operator.__lt__),
|
|
"le": (lambda a,b: a<=b, operator.le, operator.__le__),
|
|
"eq": (lambda a,b: a==b, operator.eq, operator.__eq__),
|
|
"ne": (lambda a,b: a!=b, operator.ne, operator.__ne__),
|
|
"gt": (lambda a,b: a> b, operator.gt, operator.__gt__),
|
|
"ge": (lambda a,b: a>=b, operator.ge, operator.__ge__)
|
|
}
|
|
|
|
class VectorTest(unittest.TestCase):
|
|
|
|
def checkfail(self, error, opname, *args):
|
|
for op in opmap[opname]:
|
|
self.assertRaises(error, op, *args)
|
|
|
|
def checkequal(self, opname, a, b, expres):
|
|
for op in opmap[opname]:
|
|
realres = op(a, b)
|
|
# can't use assertEqual(realres, expres) here
|
|
self.assertEqual(len(realres), len(expres))
|
|
for i in xrange(len(realres)):
|
|
# results are bool, so we can use "is" here
|
|
self.assertTrue(realres[i] is expres[i])
|
|
|
|
def test_mixed(self):
|
|
# check that comparisons involving Vector objects
|
|
# which return rich results (i.e. Vectors with itemwise
|
|
# comparison results) work
|
|
a = Vector(range(2))
|
|
b = Vector(range(3))
|
|
# all comparisons should fail for different length
|
|
for opname in opmap:
|
|
self.checkfail(ValueError, opname, a, b)
|
|
|
|
a = range(5)
|
|
b = 5 * [2]
|
|
# try mixed arguments (but not (a, b) as that won't return a bool vector)
|
|
args = [(a, Vector(b)), (Vector(a), b), (Vector(a), Vector(b))]
|
|
for (a, b) in args:
|
|
self.checkequal("lt", a, b, [True, True, False, False, False])
|
|
self.checkequal("le", a, b, [True, True, True, False, False])
|
|
self.checkequal("eq", a, b, [False, False, True, False, False])
|
|
self.checkequal("ne", a, b, [True, True, False, True, True ])
|
|
self.checkequal("gt", a, b, [False, False, False, True, True ])
|
|
self.checkequal("ge", a, b, [False, False, True, True, True ])
|
|
|
|
for ops in opmap.itervalues():
|
|
for op in ops:
|
|
# calls __nonzero__, which should fail
|
|
self.assertRaises(TypeError, bool, op(a, b))
|
|
|
|
class NumberTest(unittest.TestCase):
|
|
|
|
def test_basic(self):
|
|
# Check that comparisons involving Number objects
|
|
# give the same results give as comparing the
|
|
# corresponding ints
|
|
for a in xrange(3):
|
|
for b in xrange(3):
|
|
for typea in (int, Number):
|
|
for typeb in (int, Number):
|
|
if typea==typeb==int:
|
|
continue # the combination int, int is useless
|
|
ta = typea(a)
|
|
tb = typeb(b)
|
|
for ops in opmap.itervalues():
|
|
for op in ops:
|
|
realoutcome = op(a, b)
|
|
testoutcome = op(ta, tb)
|
|
self.assertEqual(realoutcome, testoutcome)
|
|
|
|
def checkvalue(self, opname, a, b, expres):
|
|
for typea in (int, Number):
|
|
for typeb in (int, Number):
|
|
ta = typea(a)
|
|
tb = typeb(b)
|
|
for op in opmap[opname]:
|
|
realres = op(ta, tb)
|
|
realres = getattr(realres, "x", realres)
|
|
self.assertTrue(realres is expres)
|
|
|
|
def test_values(self):
|
|
# check all operators and all comparison results
|
|
self.checkvalue("lt", 0, 0, False)
|
|
self.checkvalue("le", 0, 0, True )
|
|
self.checkvalue("eq", 0, 0, True )
|
|
self.checkvalue("ne", 0, 0, False)
|
|
self.checkvalue("gt", 0, 0, False)
|
|
self.checkvalue("ge", 0, 0, True )
|
|
|
|
self.checkvalue("lt", 0, 1, True )
|
|
self.checkvalue("le", 0, 1, True )
|
|
self.checkvalue("eq", 0, 1, False)
|
|
self.checkvalue("ne", 0, 1, True )
|
|
self.checkvalue("gt", 0, 1, False)
|
|
self.checkvalue("ge", 0, 1, False)
|
|
|
|
self.checkvalue("lt", 1, 0, False)
|
|
self.checkvalue("le", 1, 0, False)
|
|
self.checkvalue("eq", 1, 0, False)
|
|
self.checkvalue("ne", 1, 0, True )
|
|
self.checkvalue("gt", 1, 0, True )
|
|
self.checkvalue("ge", 1, 0, True )
|
|
|
|
class MiscTest(unittest.TestCase):
|
|
|
|
def test_misbehavin(self):
|
|
class Misb:
|
|
def __lt__(self_, other): return 0
|
|
def __gt__(self_, other): return 0
|
|
def __eq__(self_, other): return 0
|
|
def __le__(self_, other): self.fail("This shouldn't happen")
|
|
def __ge__(self_, other): self.fail("This shouldn't happen")
|
|
def __ne__(self_, other): self.fail("This shouldn't happen")
|
|
def __cmp__(self_, other): raise RuntimeError, "expected"
|
|
a = Misb()
|
|
b = Misb()
|
|
self.assertEqual(a<b, 0)
|
|
self.assertEqual(a==b, 0)
|
|
self.assertEqual(a>b, 0)
|
|
self.assertRaises(RuntimeError, cmp, a, b)
|
|
|
|
def test_not(self):
|
|
# Check that exceptions in __nonzero__ are properly
|
|
# propagated by the not operator
|
|
import operator
|
|
class Exc(Exception):
|
|
pass
|
|
class Bad:
|
|
def __nonzero__(self):
|
|
raise Exc
|
|
|
|
def do(bad):
|
|
not bad
|
|
|
|
for func in (do, operator.not_):
|
|
self.assertRaises(Exc, func, Bad())
|
|
|
|
def test_recursion(self):
|
|
# Check that comparison for recursive objects fails gracefully
|
|
from UserList import UserList
|
|
a = UserList()
|
|
b = UserList()
|
|
a.append(b)
|
|
b.append(a)
|
|
self.assertRaises(RuntimeError, operator.eq, a, b)
|
|
self.assertRaises(RuntimeError, operator.ne, a, b)
|
|
self.assertRaises(RuntimeError, operator.lt, a, b)
|
|
self.assertRaises(RuntimeError, operator.le, a, b)
|
|
self.assertRaises(RuntimeError, operator.gt, a, b)
|
|
self.assertRaises(RuntimeError, operator.ge, a, b)
|
|
|
|
b.append(17)
|
|
# Even recursive lists of different lengths are different,
|
|
# but they cannot be ordered
|
|
self.assertTrue(not (a == b))
|
|
self.assertTrue(a != b)
|
|
self.assertRaises(RuntimeError, operator.lt, a, b)
|
|
self.assertRaises(RuntimeError, operator.le, a, b)
|
|
self.assertRaises(RuntimeError, operator.gt, a, b)
|
|
self.assertRaises(RuntimeError, operator.ge, a, b)
|
|
a.append(17)
|
|
self.assertRaises(RuntimeError, operator.eq, a, b)
|
|
self.assertRaises(RuntimeError, operator.ne, a, b)
|
|
a.insert(0, 11)
|
|
b.insert(0, 12)
|
|
self.assertTrue(not (a == b))
|
|
self.assertTrue(a != b)
|
|
self.assertTrue(a < b)
|
|
|
|
class DictTest(unittest.TestCase):
|
|
|
|
def test_dicts(self):
|
|
# Verify that __eq__ and __ne__ work for dicts even if the keys and
|
|
# values don't support anything other than __eq__ and __ne__ (and
|
|
# __hash__). 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
|
|
self.assertTrue(imag1a == imag1a)
|
|
self.assertTrue(imag1a == imag1b)
|
|
self.assertTrue(imag2 == imag2)
|
|
self.assertTrue(imag1a != imag2)
|
|
for opname in ("lt", "le", "gt", "ge"):
|
|
for op in opmap[opname]:
|
|
self.assertRaises(TypeError, op, imag1a, imag2)
|
|
|
|
class ListTest(unittest.TestCase):
|
|
|
|
def assertIs(self, a, b):
|
|
self.assertTrue(a is b)
|
|
|
|
def test_coverage(self):
|
|
# exercise all comparisons for lists
|
|
x = [42]
|
|
self.assertIs(x<x, False)
|
|
self.assertIs(x<=x, True)
|
|
self.assertIs(x==x, True)
|
|
self.assertIs(x!=x, False)
|
|
self.assertIs(x>x, False)
|
|
self.assertIs(x>=x, True)
|
|
y = [42, 42]
|
|
self.assertIs(x<y, True)
|
|
self.assertIs(x<=y, True)
|
|
self.assertIs(x==y, False)
|
|
self.assertIs(x!=y, True)
|
|
self.assertIs(x>y, False)
|
|
self.assertIs(x>=y, False)
|
|
|
|
def test_badentry(self):
|
|
# make sure that exceptions for item comparison are properly
|
|
# propagated in list comparisons
|
|
class Exc(Exception):
|
|
pass
|
|
class Bad:
|
|
def __eq__(self, other):
|
|
raise Exc
|
|
|
|
x = [Bad()]
|
|
y = [Bad()]
|
|
|
|
for op in opmap["eq"]:
|
|
self.assertRaises(Exc, op, x, y)
|
|
|
|
def test_goodentry(self):
|
|
# This test exercises the final call to PyObject_RichCompare()
|
|
# in Objects/listobject.c::list_richcompare()
|
|
class Good:
|
|
def __lt__(self, other):
|
|
return True
|
|
|
|
x = [Good()]
|
|
y = [Good()]
|
|
|
|
for op in opmap["lt"]:
|
|
self.assertIs(op(x, y), True)
|
|
|
|
def test_main():
|
|
test_support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|