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() 339
