github.com/grumpyhome/grumpy@v0.3.1-0.20201208125205-7b775405bdf1/grumpy-runtime-src/third_party/ouroboros/test/test_operator.py (about) 1 import unittest 2 import operator 3 from test import test_support 4 5 class Seq1(object): 6 def __init__(self, lst): 7 self.lst = lst 8 def __len__(self): 9 return len(self.lst) 10 def __getitem__(self, i): 11 return self.lst[i] 12 def __add__(self, other): 13 return self.lst + other.lst 14 def __mul__(self, other): 15 return self.lst * other 16 def __rmul__(self, other): 17 return other * self.lst 18 19 class Seq2(object): 20 def __init__(self, lst): 21 self.lst = lst 22 def __len__(self): 23 return len(self.lst) 24 def __getitem__(self, i): 25 return self.lst[i] 26 def __add__(self, other): 27 return self.lst + other.lst 28 def __mul__(self, other): 29 return self.lst * other 30 def __rmul__(self, other): 31 return other * self.lst 32 33 class OperatorTestCase(unittest.TestCase): 34 def test_lt(self): 35 #operator = self.module 36 self.assertRaises(TypeError, operator.lt) 37 self.assertFalse(operator.lt(1, 0)) 38 self.assertFalse(operator.lt(1, 0.0)) 39 self.assertFalse(operator.lt(1, 1)) 40 self.assertFalse(operator.lt(1, 1.0)) 41 self.assertTrue(operator.lt(1, 2)) 42 self.assertTrue(operator.lt(1, 2.0)) 43 44 def test_le(self): 45 #operator = self.module 46 self.assertRaises(TypeError, operator.le) 47 self.assertFalse(operator.le(1, 0)) 48 self.assertFalse(operator.le(1, 0.0)) 49 self.assertTrue(operator.le(1, 1)) 50 self.assertTrue(operator.le(1, 1.0)) 51 self.assertTrue(operator.le(1, 2)) 52 self.assertTrue(operator.le(1, 2.0)) 53 54 def test_eq(self): 55 #operator = self.module 56 class C(object): 57 def __eq__(self, other): 58 raise SyntaxError 59 self.assertRaises(TypeError, operator.eq) 60 self.assertRaises(SyntaxError, operator.eq, C(), C()) 61 self.assertFalse(operator.eq(1, 0)) 62 self.assertFalse(operator.eq(1, 0.0)) 63 self.assertTrue(operator.eq(1, 1)) 64 self.assertTrue(operator.eq(1, 1.0)) 65 self.assertFalse(operator.eq(1, 2)) 66 self.assertFalse(operator.eq(1, 2.0)) 67 68 def test_ne(self): 69 #operator = self.module 70 class C(object): 71 def __ne__(self, other): 72 raise SyntaxError 73 self.assertRaises(TypeError, operator.ne) 74 self.assertRaises(SyntaxError, operator.ne, C(), C()) 75 self.assertTrue(operator.ne(1, 0)) 76 self.assertTrue(operator.ne(1, 0.0)) 77 self.assertFalse(operator.ne(1, 1)) 78 self.assertFalse(operator.ne(1, 1.0)) 79 self.assertTrue(operator.ne(1, 2)) 80 self.assertTrue(operator.ne(1, 2.0)) 81 82 def test_ge(self): 83 #operator = self.module 84 self.assertRaises(TypeError, operator.ge) 85 self.assertTrue(operator.ge(1, 0)) 86 self.assertTrue(operator.ge(1, 0.0)) 87 self.assertTrue(operator.ge(1, 1)) 88 self.assertTrue(operator.ge(1, 1.0)) 89 self.assertFalse(operator.ge(1, 2)) 90 self.assertFalse(operator.ge(1, 2.0)) 91 92 def test_gt(self): 93 #operator = self.module 94 self.assertRaises(TypeError, operator.gt) 95 self.assertTrue(operator.gt(1, 0)) 96 self.assertTrue(operator.gt(1, 0.0)) 97 self.assertFalse(operator.gt(1, 1)) 98 self.assertFalse(operator.gt(1, 1.0)) 99 self.assertFalse(operator.gt(1, 2)) 100 self.assertFalse(operator.gt(1, 2.0)) 101 102 def test_abs(self): 103 #operator = self.module 104 self.assertRaises(TypeError, operator.abs) 105 self.assertRaises(TypeError, operator.abs, None) 106 self.assertEqual(operator.abs(-1), 1) 107 self.assertEqual(operator.abs(1), 1) 108 109 def test_add(self): 110 #operator = self.module 111 self.assertRaises(TypeError, operator.add) 112 self.assertRaises(TypeError, operator.add, None, None) 113 self.assertTrue(operator.add(3, 4) == 7) 114 115 def test_bitwise_and(self): 116 #operator = self.module 117 self.assertRaises(TypeError, operator.and_) 118 self.assertRaises(TypeError, operator.and_, None, None) 119 self.assertTrue(operator.and_(0xf, 0xa) == 0xa) 120 121 def test_concat(self): 122 #operator = self.module 123 self.assertRaises(TypeError, operator.concat) 124 self.assertRaises(TypeError, operator.concat, None, None) 125 self.assertTrue(operator.concat('py', 'thon') == 'python') 126 self.assertTrue(operator.concat([1, 2], [3, 4]) == [1, 2, 3, 4]) 127 self.assertTrue(operator.concat(Seq1([5, 6]), Seq1([7])) == [5, 6, 7]) 128 self.assertTrue(operator.concat(Seq2([5, 6]), Seq2([7])) == [5, 6, 7]) 129 self.assertRaises(TypeError, operator.concat, 13, 29) 130 131 def test_countOf(self): 132 #operator = self.module 133 self.assertRaises(TypeError, operator.countOf) 134 self.assertRaises(TypeError, operator.countOf, None, None) 135 self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 3) == 1) 136 self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 5) == 0) 137 138 @unittest.expectedFailure 139 def test_delitem(self): 140 #operator = self.module 141 a = [4, 3, 2, 1] 142 self.assertRaises(TypeError, operator.delitem, a) 143 self.assertRaises(TypeError, operator.delitem, a, None) 144 self.assertTrue(operator.delitem(a, 1) is None) 145 self.assertTrue(a == [4, 2, 1]) 146 147 def test_floordiv(self): 148 #operator = self.module 149 self.assertRaises(TypeError, operator.floordiv, 5) 150 self.assertRaises(TypeError, operator.floordiv, None, None) 151 self.assertTrue(operator.floordiv(5, 2) == 2) 152 153 def test_truediv(self): 154 #operator = self.module 155 self.assertRaises(TypeError, operator.truediv, 5) 156 self.assertRaises(TypeError, operator.truediv, None, None) 157 self.assertTrue(operator.truediv(5, 2) == 2.5) 158 159 def test_getitem(self): 160 #operator = self.module 161 a = range(10) 162 self.assertRaises(TypeError, operator.getitem) 163 self.assertRaises(TypeError, operator.getitem, a, None) 164 self.assertTrue(operator.getitem(a, 2) == 2) 165 166 def test_indexOf(self): 167 #operator = self.module 168 self.assertRaises(TypeError, operator.indexOf) 169 self.assertRaises(TypeError, operator.indexOf, None, None) 170 self.assertTrue(operator.indexOf([4, 3, 2, 1], 3) == 1) 171 self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0) 172 173 def test_invert(self): 174 #operator = self.module 175 self.assertRaises(TypeError, operator.invert) 176 self.assertRaises(TypeError, operator.invert, None) 177 self.assertEqual(operator.inv(4), -5) 178 179 def test_lshift(self): 180 #operator = self.module 181 self.assertRaises(TypeError, operator.lshift) 182 self.assertRaises(TypeError, operator.lshift, None, 42) 183 self.assertTrue(operator.lshift(5, 1) == 10) 184 self.assertTrue(operator.lshift(5, 0) == 5) 185 self.assertRaises(ValueError, operator.lshift, 2, -1) 186 187 def test_mod(self): 188 #operator = self.module 189 self.assertRaises(TypeError, operator.mod) 190 self.assertRaises(TypeError, operator.mod, None, 42) 191 self.assertTrue(operator.mod(5, 2) == 1) 192 193 def test_mul(self): 194 #operator = self.module 195 self.assertRaises(TypeError, operator.mul) 196 self.assertRaises(TypeError, operator.mul, None, None) 197 self.assertTrue(operator.mul(5, 2) == 10) 198 199 def test_neg(self): 200 #operator = self.module 201 self.assertRaises(TypeError, operator.neg) 202 self.assertRaises(TypeError, operator.neg, None) 203 self.assertEqual(operator.neg(5), -5) 204 self.assertEqual(operator.neg(-5), 5) 205 self.assertEqual(operator.neg(0), 0) 206 self.assertEqual(operator.neg(-0), 0) 207 208 def test_bitwise_or(self): 209 #operator = self.module 210 self.assertRaises(TypeError, operator.or_) 211 self.assertRaises(TypeError, operator.or_, None, None) 212 self.assertTrue(operator.or_(0xa, 0x5) == 0xf) 213 214 def test_pos(self): 215 #operator = self.module 216 self.assertRaises(TypeError, operator.pos) 217 self.assertRaises(TypeError, operator.pos, None) 218 self.assertEqual(operator.pos(5), 5) 219 self.assertEqual(operator.pos(-5), -5) 220 self.assertEqual(operator.pos(0), 0) 221 self.assertEqual(operator.pos(-0), 0) 222 223 def test_pow(self): 224 #operator = self.module 225 self.assertRaises(TypeError, operator.pow) 226 self.assertRaises(TypeError, operator.pow, None, None) 227 self.assertEqual(operator.pow(3,5), 3**5) 228 self.assertRaises(TypeError, operator.pow, 1) 229 self.assertRaises(TypeError, operator.pow, 1, 2, 3) 230 231 def test_rshift(self): 232 #operator = self.module 233 self.assertRaises(TypeError, operator.rshift) 234 self.assertRaises(TypeError, operator.rshift, None, 42) 235 self.assertTrue(operator.rshift(5, 1) == 2) 236 self.assertTrue(operator.rshift(5, 0) == 5) 237 self.assertRaises(ValueError, operator.rshift, 2, -1) 238 239 def test_contains(self): 240 #operator = self.module 241 self.assertRaises(TypeError, operator.contains) 242 self.assertRaises(TypeError, operator.contains, None, None) 243 self.assertTrue(operator.contains(range(4), 2)) 244 self.assertFalse(operator.contains(range(4), 5)) 245 246 def test_setitem(self): 247 #operator = self.module 248 a = list(range(3)) 249 self.assertRaises(TypeError, operator.setitem, a) 250 self.assertRaises(TypeError, operator.setitem, a, None, None) 251 self.assertTrue(operator.setitem(a, 0, 2) is None) 252 self.assertTrue(a == [2, 1, 2]) 253 self.assertRaises(IndexError, operator.setitem, a, 4, 2) 254 255 def test_sub(self): 256 #operator = self.module 257 self.assertRaises(TypeError, operator.sub) 258 self.assertRaises(TypeError, operator.sub, None, None) 259 self.assertTrue(operator.sub(5, 2) == 3) 260 261 @unittest.expectedFailure 262 def test_truth(self): 263 #operator = self.module 264 class C(object): 265 def __bool__(self): 266 raise SyntaxError 267 self.assertRaises(TypeError, operator.truth) 268 self.assertRaises(SyntaxError, operator.truth, C()) 269 self.assertTrue(operator.truth(5)) 270 self.assertTrue(operator.truth([0])) 271 self.assertFalse(operator.truth(0)) 272 self.assertFalse(operator.truth([])) 273 274 def test_bitwise_xor(self): 275 #operator = self.module 276 self.assertRaises(TypeError, operator.xor) 277 self.assertRaises(TypeError, operator.xor, None, None) 278 self.assertTrue(operator.xor(0xb, 0xc) == 0x7) 279 280 def test_is(self): 281 #operator = self.module 282 a = b = 'xyzpdq' 283 c = a[:3] + b[3:] 284 self.assertRaises(TypeError, operator.is_) 285 self.assertTrue(operator.is_(a, b)) 286 #self.assertFalse(operator.is_(a,c)) 287 288 @unittest.expectedFailure 289 def test_is_not(self): 290 #operator = self.module 291 a = b = 'xyzpdq' 292 c = a[:3] + b[3:] 293 self.assertRaises(TypeError, operator.is_not) 294 self.assertFalse(operator.is_not(a, b)) 295 self.assertTrue(operator.is_not(a,c)) 296 297 @unittest.expectedFailure 298 def test_attrgetter(self): 299 #operator = self.module 300 class A(object): 301 pass 302 a = A() 303 a.name = 'arthur' 304 f = operator.attrgetter('name') 305 self.assertEqual(f(a), 'arthur') 306 f = operator.attrgetter('rank') 307 self.assertRaises(AttributeError, f, a) 308 self.assertRaises(TypeError, operator.attrgetter, 2) 309 self.assertRaises(TypeError, operator.attrgetter) 310 311 # multiple gets 312 record = A() 313 record.x = 'X' 314 record.y = 'Y' 315 record.z = 'Z' 316 self.assertEqual(operator.attrgetter('x','z','y')(record), ('X', 'Z', 'Y')) 317 self.assertRaises(TypeError, operator.attrgetter, ('x', (), 'y')) 318 319 class C(object): 320 def __getattr__(self, name): 321 raise SyntaxError 322 self.assertRaises(SyntaxError, operator.attrgetter('foo'), C()) 323 324 # recursive gets 325 a = A() 326 a.name = 'arthur' 327 a.child = A() 328 a.child.name = 'thomas' 329 f = operator.attrgetter('child.name') 330 self.assertEqual(f(a), 'thomas') 331 self.assertRaises(AttributeError, f, a.child) 332 f = operator.attrgetter('name', 'child.name') 333 self.assertEqual(f(a), ('arthur', 'thomas')) 334 f = operator.attrgetter('name', 'child.name', 'child.child.name') 335 self.assertRaises(AttributeError, f, a) 336 f = operator.attrgetter('child.') 337 self.assertRaises(AttributeError, f, a) 338 f = operator.attrgetter('.child') 339 self.assertRaises(AttributeError, f, a) 340 341 a.child.child = A() 342 a.child.child.name = 'johnson' 343 f = operator.attrgetter('child.child.name') 344 self.assertEqual(f(a), 'johnson') 345 f = operator.attrgetter('name', 'child.name', 'child.child.name') 346 self.assertEqual(f(a), ('arthur', 'thomas', 'johnson')) 347 348 @unittest.expectedFailure 349 def test_itemgetter(self): 350 #operator = self.module 351 a = 'ABCDE' 352 f = operator.itemgetter(2) 353 self.assertEqual(f(a), 'C') 354 f = operator.itemgetter(10) 355 self.assertRaises(IndexError, f, a) 356 357 class C(object): 358 def __getitem__(self, name): 359 raise SyntaxError 360 self.assertRaises(SyntaxError, operator.itemgetter(42), C()) 361 362 f = operator.itemgetter('name') 363 self.assertRaises(TypeError, f, a) 364 self.assertRaises(TypeError, operator.itemgetter) 365 366 d = dict(key='val') 367 f = operator.itemgetter('key') 368 self.assertEqual(f(d), 'val') 369 f = operator.itemgetter('nonkey') 370 self.assertRaises(KeyError, f, d) 371 372 # example used in the docs 373 inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)] 374 getcount = operator.itemgetter(1) 375 self.assertEqual(list(map(getcount, inventory)), [3, 2, 5, 1]) 376 self.assertEqual(sorted(inventory, key=getcount), 377 [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]) 378 379 # multiple gets 380 data = list(map(str, range(20))) 381 self.assertEqual(operator.itemgetter(2,10,5)(data), ('2', '10', '5')) 382 self.assertRaises(TypeError, operator.itemgetter(2, 'x', 5), data) 383 384 def test_methodcaller(self): 385 #operator = self.module 386 self.assertRaises(TypeError, operator.methodcaller) 387 class A(object): 388 def foo(self, *args, **kwds): 389 return args[0] + args[1] 390 def bar(self, f=42): 391 return f 392 def baz(*args, **kwds): 393 return kwds['name'], kwds['self'] 394 a = A() 395 f = operator.methodcaller('foo') 396 self.assertRaises(IndexError, f, a) 397 f = operator.methodcaller('foo', 1, 2) 398 self.assertEqual(f(a), 3) 399 f = operator.methodcaller('bar') 400 self.assertEqual(f(a), 42) 401 self.assertRaises(TypeError, f, a, a) 402 f = operator.methodcaller('bar', f=5) 403 self.assertEqual(f(a), 5) 404 f = operator.methodcaller('baz', name='spam', self='eggs') 405 self.assertEqual(f(a), ('spam', 'eggs')) 406 407 @unittest.expectedFailure 408 def test_inplace(self): 409 #operator = self.module 410 class C(object): 411 def __iadd__ (self, other): return "iadd" 412 def __iand__ (self, other): return "iand" 413 def __ifloordiv__(self, other): return "ifloordiv" 414 def __ilshift__ (self, other): return "ilshift" 415 def __imod__ (self, other): return "imod" 416 def __imul__ (self, other): return "imul" 417 def __ior__ (self, other): return "ior" 418 def __ipow__ (self, other): return "ipow" 419 def __irshift__ (self, other): return "irshift" 420 def __isub__ (self, other): return "isub" 421 def __itruediv__ (self, other): return "itruediv" 422 def __ixor__ (self, other): return "ixor" 423 def __getitem__(self, other): return 5 # so that C is a sequence 424 c = C() 425 self.assertEqual(operator.iadd (c, 5), "iadd") 426 self.assertEqual(operator.iand (c, 5), "iand") 427 self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv") 428 self.assertEqual(operator.ilshift (c, 5), "ilshift") 429 self.assertEqual(operator.imod (c, 5), "imod") 430 self.assertEqual(operator.imul (c, 5), "imul") 431 self.assertEqual(operator.ior (c, 5), "ior") 432 self.assertEqual(operator.ipow (c, 5), "ipow") 433 self.assertEqual(operator.irshift (c, 5), "irshift") 434 self.assertEqual(operator.isub (c, 5), "isub") 435 self.assertEqual(operator.itruediv (c, 5), "itruediv") 436 self.assertEqual(operator.ixor (c, 5), "ixor") 437 self.assertEqual(operator.iconcat (c, c), "iadd") 438 439 @unittest.expectedFailure 440 def test_length_hint(self): 441 #operator = self.module 442 class X(object): 443 def __init__(self, value): 444 self.value = value 445 446 def __length_hint__(self): 447 if type(self.value) is type: 448 raise self.value 449 else: 450 return self.value 451 452 self.assertEqual(operator.length_hint([], 2), 0) 453 self.assertEqual(operator.length_hint(iter([1, 2, 3])), 3) 454 455 self.assertEqual(operator.length_hint(X(2)), 2) 456 self.assertEqual(operator.length_hint(X(NotImplemented), 4), 4) 457 self.assertEqual(operator.length_hint(X(TypeError), 12), 12) 458 with self.assertRaises(TypeError): 459 operator.length_hint(X("abc")) 460 with self.assertRaises(ValueError): 461 operator.length_hint(X(-2)) 462 with self.assertRaises(LookupError): 463 operator.length_hint(X(LookupError)) 464 465 def test_dunder_is_original(self): 466 #operator = self.module 467 468 names = [name for name in dir(operator) if not name.startswith('_')] 469 for name in names: 470 orig = getattr(operator, name) 471 dunder = getattr(operator, '__' + name.strip('_') + '__', None) 472 if dunder: 473 self.assertIs(dunder, orig) 474 475 def test_complex_operator(self): 476 self.assertRaises(TypeError, operator.lt, 1j, 2j) 477 self.assertRaises(TypeError, operator.le, 1j, 2j) 478 self.assertRaises(TypeError, operator.ge, 1j, 2j) 479 self.assertRaises(TypeError, operator.gt, 1j, 2j) 480 def test_main(): 481 test_support.run_unittest(OperatorTestCase) 482 483 if __name__ == "__main__": 484 test_main()