summaryrefslogtreecommitdiff
path: root/lib/python2.7/test/test_richcmp.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/test/test_richcmp.py')
-rw-r--r--lib/python2.7/test/test_richcmp.py338
1 files changed, 0 insertions, 338 deletions
diff --git a/lib/python2.7/test/test_richcmp.py b/lib/python2.7/test/test_richcmp.py
deleted file mode 100644
index 70fa0d8..0000000
--- a/lib/python2.7/test/test_richcmp.py
+++ /dev/null
@@ -1,338 +0,0 @@
-# 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 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, ListTest)
- with test_support.check_py3k_warnings(("dict inequality comparisons "
- "not supported in 3.x",
- DeprecationWarning)):
- test_support.run_unittest(DictTest)
-
-
-if __name__ == "__main__":
- test_main()
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-17 14:51:46 +0000