AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_richcmp.py

   1 # Tests for rich comparisons
   2
   3 import unittest
   4 from test import test_support
   5
   6 import operator
   7
   8 class Number:
   9
  10     def __init__(self, x):
  11         self.x = x
  12
  13     def __lt__(self, other):
  14         return self.x < other
  15
  16     def __le__(self, other):
  17         return self.x <= other
  18
  19     def __eq__(self, other):
  20         return self.x == other
  21
  22     def __ne__(self, other):
  23         return self.x != other
  24
  25     def __gt__(self, other):
  26         return self.x > other
  27
  28     def __ge__(self, other):
  29         return self.x >= other
  30
  31     def __cmp__(self, other):
  32         raise test_support.TestFailed, "Number.__cmp__() should not be called"
  33
  34     def __repr__(self):
  35         return "Number(%r)" % (self.x, )
  36
  37 class Vector:
  38
  39     def __init__(self, data):
  40         self.data = data
  41
  42     def __len__(self):
  43         return len(self.data)
  44
  45     def __getitem__(self, i):
  46         return self.data[i]
  47
  48     def __setitem__(self, i, v):
  49         self.data[i] = v
  50
  51     __hash__ = None # Vectors cannot be hashed
  52
  53     def __nonzero__(self):
  54         raise TypeError, "Vectors cannot be used in Boolean contexts"
  55
  56     def __cmp__(self, other):
  57         raise test_support.TestFailed, "Vector.__cmp__() should not be called"
  58
  59     def __repr__(self):
  60         return "Vector(%r)" % (self.data, )
  61
  62     def __lt__(self, other):
  63         return Vector([a < b for a, b in zip(self.data, self.__cast(other))])
  64
  65     def __le__(self, other):
  66         return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
  67
  68     def __eq__(self, other):
  69         return Vector([a == b for a, b in zip(self.data, self.__cast(other))])
  70
  71     def __ne__(self, other):
  72         return Vector([a != b for a, b in zip(self.data, self.__cast(other))])
  73
  74     def __gt__(self, other):
  75         return Vector([a > b for a, b in zip(self.data, self.__cast(other))])
  76
  77     def __ge__(self, other):
  78         return Vector([a >= b for a, b in zip(self.data, self.__cast(other))])
  79
  80     def __cast(self, other):
  81         if isinstance(other, Vector):
  82             other = other.data
  83         if len(self.data) != len(other):
  84             raise ValueError, "Cannot compare vectors of different length"
  85         return other
  86
  87 opmap = {
  88     "lt": (lambda a,b: a< b, operator.lt, operator.__lt__),
  89     "le": (lambda a,b: a<=b, operator.le, operator.__le__),
  90     "eq": (lambda a,b: a==b, operator.eq, operator.__eq__),
  91     "ne": (lambda a,b: a!=b, operator.ne, operator.__ne__),
  92     "gt": (lambda a,b: a> b, operator.gt, operator.__gt__),
  93     "ge": (lambda a,b: a>=b, operator.ge, operator.__ge__)
  94 }
  95
  96 class VectorTest(unittest.TestCase):
  97
  98     def checkfail(self, error, opname, *args):
  99         for op in opmap[opname]:
 100             self.assertRaises(error, op, *args)
 101
 102     def checkequal(self, opname, a, b, expres):
 103         for op in opmap[opname]:
 104             realres = op(a, b)
 105             # can't use assertEqual(realres, expres) here
 106             self.assertEqual(len(realres), len(expres))
 107             for i in xrange(len(realres)):
 108                 # results are bool, so we can use "is" here
 109                 self.assertTrue(realres[i] is expres[i])
 110
 111     def test_mixed(self):
 112         # check that comparisons involving Vector objects
 113         # which return rich results (i.e. Vectors with itemwise
 114         # comparison results) work
 115         a = Vector(range(2))
 116         b = Vector(range(3))
 117         # all comparisons should fail for different length
 118         for opname in opmap:
 119             self.checkfail(ValueError, opname, a, b)
 120
 121         a = range(5)
 122         b = 5 * [2]
 123         # try mixed arguments (but not (a, b) as that won't return a bool vector)
 124         args = [(a, Vector(b)), (Vector(a), b), (Vector(a), Vector(b))]
 125         for (a, b) in args:
 126             self.checkequal("lt", a, b, [True,  True,  False, False, False])
 127             self.checkequal("le", a, b, [True,  True,  True,  False, False])
 128             self.checkequal("eq", a, b, [False, False, True,  False, False])
 129             self.checkequal("ne", a, b, [True,  True,  False, True,  True ])
 130             self.checkequal("gt", a, b, [False, False, False, True,  True ])
 131             self.checkequal("ge", a, b, [False, False, True,  True,  True ])
 132
 133             for ops in opmap.itervalues():
 134                 for op in ops:
 135                     # calls __nonzero__, which should fail
 136                     self.assertRaises(TypeError, bool, op(a, b))
 137
 138 class NumberTest(unittest.TestCase):
 139
 140     def test_basic(self):
 141         # Check that comparisons involving Number objects
 142         # give the same results give as comparing the
 143         # corresponding ints
 144         for a in xrange(3):
 145             for b in xrange(3):
 146                 for typea in (int, Number):
 147                     for typeb in (int, Number):
 148                         if typea==typeb==int:
 149                             continue # the combination int, int is useless
 150                         ta = typea(a)
 151                         tb = typeb(b)
 152                         for ops in opmap.itervalues():
 153                             for op in ops:
 154                                 realoutcome = op(a, b)
 155                                 testoutcome = op(ta, tb)
 156                                 self.assertEqual(realoutcome, testoutcome)
 157
 158     def checkvalue(self, opname, a, b, expres):
 159         for typea in (int, Number):
 160             for typeb in (int, Number):
 161                 ta = typea(a)
 162                 tb = typeb(b)
 163                 for op in opmap[opname]:
 164                     realres = op(ta, tb)
 165                     realres = getattr(realres, "x", realres)
 166                     self.assertTrue(realres is expres)
 167
 168     def test_values(self):
 169         # check all operators and all comparison results
 170         self.checkvalue("lt", 0, 0, False)
 171         self.checkvalue("le", 0, 0, True )
 172         self.checkvalue("eq", 0, 0, True )
 173         self.checkvalue("ne", 0, 0, False)
 174         self.checkvalue("gt", 0, 0, False)
 175         self.checkvalue("ge", 0, 0, True )
 176
 177         self.checkvalue("lt", 0, 1, True )
 178         self.checkvalue("le", 0, 1, True )
 179         self.checkvalue("eq", 0, 1, False)
 180         self.checkvalue("ne", 0, 1, True )
 181         self.checkvalue("gt", 0, 1, False)
 182         self.checkvalue("ge", 0, 1, False)
 183
 184         self.checkvalue("lt", 1, 0, False)
 185         self.checkvalue("le", 1, 0, False)
 186         self.checkvalue("eq", 1, 0, False)
 187         self.checkvalue("ne", 1, 0, True )
 188         self.checkvalue("gt", 1, 0, True )
 189         self.checkvalue("ge", 1, 0, True )
 190
 191 class MiscTest(unittest.TestCase):
 192
 193     def test_misbehavin(self):
 194         class Misb:
 195             def __lt__(self_, other): return 0
 196             def __gt__(self_, other): return 0
 197             def __eq__(self_, other): return 0
 198             def __le__(self_, other): self.fail("This shouldn't happen")
 199             def __ge__(self_, other): self.fail("This shouldn't happen")
 200             def __ne__(self_, other): self.fail("This shouldn't happen")
 201             def __cmp__(self_, other): raise RuntimeError, "expected"
 202         a = Misb()
 203         b = Misb()
 204         self.assertEqual(a<b, 0)
 205         self.assertEqual(a==b, 0)
 206         self.assertEqual(a>b, 0)
 207         self.assertRaises(RuntimeError, cmp, a, b)
 208
 209     def test_not(self):
 210         # Check that exceptions in __nonzero__ are properly
 211         # propagated by the not operator
 212         import operator
 213         class Exc(Exception):
 214             pass
 215         class Bad:
 216             def __nonzero__(self):
 217                 raise Exc
 218
 219         def do(bad):
 220             not bad
 221
 222         for func in (do, operator.not_):
 223             self.assertRaises(Exc, func, Bad())
 224
 225     def test_recursion(self):
 226         # Check that comparison for recursive objects fails gracefully
 227         from UserList import UserList
 228         a = UserList()
 229         b = UserList()
 230         a.append(b)
 231         b.append(a)
 232         self.assertRaises(RuntimeError, operator.eq, a, b)
 233         self.assertRaises(RuntimeError, operator.ne, a, b)
 234         self.assertRaises(RuntimeError, operator.lt, a, b)
 235         self.assertRaises(RuntimeError, operator.le, a, b)
 236         self.assertRaises(RuntimeError, operator.gt, a, b)
 237         self.assertRaises(RuntimeError, operator.ge, a, b)
 238
 239         b.append(17)
 240         # Even recursive lists of different lengths are different,
 241         # but they cannot be ordered
 242         self.assertTrue(not (a == b))
 243         self.assertTrue(a != b)
 244         self.assertRaises(RuntimeError, operator.lt, a, b)
 245         self.assertRaises(RuntimeError, operator.le, a, b)
 246         self.assertRaises(RuntimeError, operator.gt, a, b)
 247         self.assertRaises(RuntimeError, operator.ge, a, b)
 248         a.append(17)
 249         self.assertRaises(RuntimeError, operator.eq, a, b)
 250         self.assertRaises(RuntimeError, operator.ne, a, b)
 251         a.insert(0, 11)
 252         b.insert(0, 12)
 253         self.assertTrue(not (a == b))
 254         self.assertTrue(a != b)
 255         self.assertTrue(a < b)
 256
 257 class DictTest(unittest.TestCase):
 258
 259     def test_dicts(self):
 260         # Verify that __eq__ and __ne__ work for dicts even if the keys and
 261         # values don't support anything other than __eq__ and __ne__ (and
 262         # __hash__).  Complex numbers are a fine example of that.
 263         import random
 264         imag1a = {}
 265         for i in range(50):
 266             imag1a[random.randrange(100)*1j] = random.randrange(100)*1j
 267         items = imag1a.items()
 268         random.shuffle(items)
 269         imag1b = {}
 270         for k, v in items:
 271             imag1b[k] = v
 272         imag2 = imag1b.copy()
 273         imag2[k] = v + 1.0
 274         self.assertTrue(imag1a == imag1a)
 275         self.assertTrue(imag1a == imag1b)
 276         self.assertTrue(imag2 == imag2)
 277         self.assertTrue(imag1a != imag2)
 278         for opname in ("lt", "le", "gt", "ge"):
 279             for op in opmap[opname]:
 280                 self.assertRaises(TypeError, op, imag1a, imag2)
 281
 282 class ListTest(unittest.TestCase):
 283
 284     def test_coverage(self):
 285         # exercise all comparisons for lists
 286         x = [42]
 287         self.assertIs(x<x, False)
 288         self.assertIs(x<=x, True)
 289         self.assertIs(x==x, True)
 290         self.assertIs(x!=x, False)
 291         self.assertIs(x>x, False)
 292         self.assertIs(x>=x, True)
 293         y = [42, 42]
 294         self.assertIs(x<y, True)
 295         self.assertIs(x<=y, True)
 296         self.assertIs(x==y, False)
 297         self.assertIs(x!=y, True)
 298         self.assertIs(x>y, False)
 299         self.assertIs(x>=y, False)
 300
 301     def test_badentry(self):
 302         # make sure that exceptions for item comparison are properly
 303         # propagated in list comparisons
 304         class Exc(Exception):
 305             pass
 306         class Bad:
 307             def __eq__(self, other):
 308                 raise Exc
 309
 310         x = [Bad()]
 311         y = [Bad()]
 312
 313         for op in opmap["eq"]:
 314             self.assertRaises(Exc, op, x, y)
 315
 316     def test_goodentry(self):
 317         # This test exercises the final call to PyObject_RichCompare()
 318         # in Objects/listobject.c::list_richcompare()
 319         class Good:
 320             def __lt__(self, other):
 321                 return True
 322
 323         x = [Good()]
 324         y = [Good()]
 325
 326         for op in opmap["lt"]:
 327             self.assertIs(op(x, y), True)
 328
 329 def test_main():
 330     test_support.run_unittest(VectorTest, NumberTest, MiscTest, ListTest)
 331     with test_support.check_py3k_warnings(("dict inequality comparisons "
 332                                              "not supported in 3.x",
 333                                              DeprecationWarning)):
 334         test_support.run_unittest(DictTest)
 335
 336
 337 if __name__ == "__main__":
 338     test_main()