1import unittest 2import pickle 3import sys 4 5from test import support 6 7py_operator = support.import_fresh_module('operator', blocked=['_operator']) 8c_operator = support.import_fresh_module('operator', fresh=['_operator']) 9 10class Seq1: 11 def __init__(self, lst): 12 self.lst = lst 13 def __len__(self): 14 return len(self.lst) 15 def __getitem__(self, i): 16 return self.lst[i] 17 def __add__(self, other): 18 return self.lst + other.lst 19 def __mul__(self, other): 20 return self.lst * other 21 def __rmul__(self, other): 22 return other * self.lst 23 24class Seq2(object): 25 def __init__(self, lst): 26 self.lst = lst 27 def __len__(self): 28 return len(self.lst) 29 def __getitem__(self, i): 30 return self.lst[i] 31 def __add__(self, other): 32 return self.lst + other.lst 33 def __mul__(self, other): 34 return self.lst * other 35 def __rmul__(self, other): 36 return other * self.lst 37 38class BadIterable: 39 def __iter__(self): 40 raise ZeroDivisionError 41 42 43class OperatorTestCase: 44 def test_lt(self): 45 operator = self.module 46 self.assertRaises(TypeError, operator.lt) 47 self.assertRaises(TypeError, operator.lt, 1j, 2j) 48 self.assertFalse(operator.lt(1, 0)) 49 self.assertFalse(operator.lt(1, 0.0)) 50 self.assertFalse(operator.lt(1, 1)) 51 self.assertFalse(operator.lt(1, 1.0)) 52 self.assertTrue(operator.lt(1, 2)) 53 self.assertTrue(operator.lt(1, 2.0)) 54 55 def test_le(self): 56 operator = self.module 57 self.assertRaises(TypeError, operator.le) 58 self.assertRaises(TypeError, operator.le, 1j, 2j) 59 self.assertFalse(operator.le(1, 0)) 60 self.assertFalse(operator.le(1, 0.0)) 61 self.assertTrue(operator.le(1, 1)) 62 self.assertTrue(operator.le(1, 1.0)) 63 self.assertTrue(operator.le(1, 2)) 64 self.assertTrue(operator.le(1, 2.0)) 65 66 def test_eq(self): 67 operator = self.module 68 class C(object): 69 def __eq__(self, other): 70 raise SyntaxError 71 self.assertRaises(TypeError, operator.eq) 72 self.assertRaises(SyntaxError, operator.eq, C(), C()) 73 self.assertFalse(operator.eq(1, 0)) 74 self.assertFalse(operator.eq(1, 0.0)) 75 self.assertTrue(operator.eq(1, 1)) 76 self.assertTrue(operator.eq(1, 1.0)) 77 self.assertFalse(operator.eq(1, 2)) 78 self.assertFalse(operator.eq(1, 2.0)) 79 80 def test_ne(self): 81 operator = self.module 82 class C(object): 83 def __ne__(self, other): 84 raise SyntaxError 85 self.assertRaises(TypeError, operator.ne) 86 self.assertRaises(SyntaxError, operator.ne, C(), C()) 87 self.assertTrue(operator.ne(1, 0)) 88 self.assertTrue(operator.ne(1, 0.0)) 89 self.assertFalse(operator.ne(1, 1)) 90 self.assertFalse(operator.ne(1, 1.0)) 91 self.assertTrue(operator.ne(1, 2)) 92 self.assertTrue(operator.ne(1, 2.0)) 93 94 def test_ge(self): 95 operator = self.module 96 self.assertRaises(TypeError, operator.ge) 97 self.assertRaises(TypeError, operator.ge, 1j, 2j) 98 self.assertTrue(operator.ge(1, 0)) 99 self.assertTrue(operator.ge(1, 0.0)) 100 self.assertTrue(operator.ge(1, 1)) 101 self.assertTrue(operator.ge(1, 1.0)) 102 self.assertFalse(operator.ge(1, 2)) 103 self.assertFalse(operator.ge(1, 2.0)) 104 105 def test_gt(self): 106 operator = self.module 107 self.assertRaises(TypeError, operator.gt) 108 self.assertRaises(TypeError, operator.gt, 1j, 2j) 109 self.assertTrue(operator.gt(1, 0)) 110 self.assertTrue(operator.gt(1, 0.0)) 111 self.assertFalse(operator.gt(1, 1)) 112 self.assertFalse(operator.gt(1, 1.0)) 113 self.assertFalse(operator.gt(1, 2)) 114 self.assertFalse(operator.gt(1, 2.0)) 115 116 def test_abs(self): 117 operator = self.module 118 self.assertRaises(TypeError, operator.abs) 119 self.assertRaises(TypeError, operator.abs, None) 120 self.assertEqual(operator.abs(-1), 1) 121 self.assertEqual(operator.abs(1), 1) 122 123 def test_add(self): 124 operator = self.module 125 self.assertRaises(TypeError, operator.add) 126 self.assertRaises(TypeError, operator.add, None, None) 127 self.assertEqual(operator.add(3, 4), 7) 128 129 def test_bitwise_and(self): 130 operator = self.module 131 self.assertRaises(TypeError, operator.and_) 132 self.assertRaises(TypeError, operator.and_, None, None) 133 self.assertEqual(operator.and_(0xf, 0xa), 0xa) 134 135 def test_concat(self): 136 operator = self.module 137 self.assertRaises(TypeError, operator.concat) 138 self.assertRaises(TypeError, operator.concat, None, None) 139 self.assertEqual(operator.concat('py', 'thon'), 'python') 140 self.assertEqual(operator.concat([1, 2], [3, 4]), [1, 2, 3, 4]) 141 self.assertEqual(operator.concat(Seq1([5, 6]), Seq1([7])), [5, 6, 7]) 142 self.assertEqual(operator.concat(Seq2([5, 6]), Seq2([7])), [5, 6, 7]) 143 self.assertRaises(TypeError, operator.concat, 13, 29) 144 145 def test_countOf(self): 146 operator = self.module 147 self.assertRaises(TypeError, operator.countOf) 148 self.assertRaises(TypeError, operator.countOf, None, None) 149 self.assertRaises(ZeroDivisionError, operator.countOf, BadIterable(), 1) 150 self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 3), 1) 151 self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 5), 0) 152 153 def test_delitem(self): 154 operator = self.module 155 a = [4, 3, 2, 1] 156 self.assertRaises(TypeError, operator.delitem, a) 157 self.assertRaises(TypeError, operator.delitem, a, None) 158 self.assertIsNone(operator.delitem(a, 1)) 159 self.assertEqual(a, [4, 2, 1]) 160 161 def test_floordiv(self): 162 operator = self.module 163 self.assertRaises(TypeError, operator.floordiv, 5) 164 self.assertRaises(TypeError, operator.floordiv, None, None) 165 self.assertEqual(operator.floordiv(5, 2), 2) 166 167 def test_truediv(self): 168 operator = self.module 169 self.assertRaises(TypeError, operator.truediv, 5) 170 self.assertRaises(TypeError, operator.truediv, None, None) 171 self.assertEqual(operator.truediv(5, 2), 2.5) 172 173 def test_getitem(self): 174 operator = self.module 175 a = range(10) 176 self.assertRaises(TypeError, operator.getitem) 177 self.assertRaises(TypeError, operator.getitem, a, None) 178 self.assertEqual(operator.getitem(a, 2), 2) 179 180 def test_indexOf(self): 181 operator = self.module 182 self.assertRaises(TypeError, operator.indexOf) 183 self.assertRaises(TypeError, operator.indexOf, None, None) 184 self.assertRaises(ZeroDivisionError, operator.indexOf, BadIterable(), 1) 185 self.assertEqual(operator.indexOf([4, 3, 2, 1], 3), 1) 186 self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0) 187 188 def test_invert(self): 189 operator = self.module 190 self.assertRaises(TypeError, operator.invert) 191 self.assertRaises(TypeError, operator.invert, None) 192 self.assertEqual(operator.inv(4), -5) 193 194 def test_lshift(self): 195 operator = self.module 196 self.assertRaises(TypeError, operator.lshift) 197 self.assertRaises(TypeError, operator.lshift, None, 42) 198 self.assertEqual(operator.lshift(5, 1), 10) 199 self.assertEqual(operator.lshift(5, 0), 5) 200 self.assertRaises(ValueError, operator.lshift, 2, -1) 201 202 def test_mod(self): 203 operator = self.module 204 self.assertRaises(TypeError, operator.mod) 205 self.assertRaises(TypeError, operator.mod, None, 42) 206 self.assertEqual(operator.mod(5, 2), 1) 207 208 def test_mul(self): 209 operator = self.module 210 self.assertRaises(TypeError, operator.mul) 211 self.assertRaises(TypeError, operator.mul, None, None) 212 self.assertEqual(operator.mul(5, 2), 10) 213 214 def test_matmul(self): 215 operator = self.module 216 self.assertRaises(TypeError, operator.matmul) 217 self.assertRaises(TypeError, operator.matmul, 42, 42) 218 class M: 219 def __matmul__(self, other): 220 return other - 1 221 self.assertEqual(M() @ 42, 41) 222 223 def test_neg(self): 224 operator = self.module 225 self.assertRaises(TypeError, operator.neg) 226 self.assertRaises(TypeError, operator.neg, None) 227 self.assertEqual(operator.neg(5), -5) 228 self.assertEqual(operator.neg(-5), 5) 229 self.assertEqual(operator.neg(0), 0) 230 self.assertEqual(operator.neg(-0), 0) 231 232 def test_bitwise_or(self): 233 operator = self.module 234 self.assertRaises(TypeError, operator.or_) 235 self.assertRaises(TypeError, operator.or_, None, None) 236 self.assertEqual(operator.or_(0xa, 0x5), 0xf) 237 238 def test_pos(self): 239 operator = self.module 240 self.assertRaises(TypeError, operator.pos) 241 self.assertRaises(TypeError, operator.pos, None) 242 self.assertEqual(operator.pos(5), 5) 243 self.assertEqual(operator.pos(-5), -5) 244 self.assertEqual(operator.pos(0), 0) 245 self.assertEqual(operator.pos(-0), 0) 246 247 def test_pow(self): 248 operator = self.module 249 self.assertRaises(TypeError, operator.pow) 250 self.assertRaises(TypeError, operator.pow, None, None) 251 self.assertEqual(operator.pow(3,5), 3**5) 252 self.assertRaises(TypeError, operator.pow, 1) 253 self.assertRaises(TypeError, operator.pow, 1, 2, 3) 254 255 def test_rshift(self): 256 operator = self.module 257 self.assertRaises(TypeError, operator.rshift) 258 self.assertRaises(TypeError, operator.rshift, None, 42) 259 self.assertEqual(operator.rshift(5, 1), 2) 260 self.assertEqual(operator.rshift(5, 0), 5) 261 self.assertRaises(ValueError, operator.rshift, 2, -1) 262 263 def test_contains(self): 264 operator = self.module 265 self.assertRaises(TypeError, operator.contains) 266 self.assertRaises(TypeError, operator.contains, None, None) 267 self.assertRaises(ZeroDivisionError, operator.contains, BadIterable(), 1) 268 self.assertTrue(operator.contains(range(4), 2)) 269 self.assertFalse(operator.contains(range(4), 5)) 270 271 def test_setitem(self): 272 operator = self.module 273 a = list(range(3)) 274 self.assertRaises(TypeError, operator.setitem, a) 275 self.assertRaises(TypeError, operator.setitem, a, None, None) 276 self.assertIsNone(operator.setitem(a, 0, 2)) 277 self.assertEqual(a, [2, 1, 2]) 278 self.assertRaises(IndexError, operator.setitem, a, 4, 2) 279 280 def test_sub(self): 281 operator = self.module 282 self.assertRaises(TypeError, operator.sub) 283 self.assertRaises(TypeError, operator.sub, None, None) 284 self.assertEqual(operator.sub(5, 2), 3) 285 286 def test_truth(self): 287 operator = self.module 288 class C(object): 289 def __bool__(self): 290 raise SyntaxError 291 self.assertRaises(TypeError, operator.truth) 292 self.assertRaises(SyntaxError, operator.truth, C()) 293 self.assertTrue(operator.truth(5)) 294 self.assertTrue(operator.truth([0])) 295 self.assertFalse(operator.truth(0)) 296 self.assertFalse(operator.truth([])) 297 298 def test_bitwise_xor(self): 299 operator = self.module 300 self.assertRaises(TypeError, operator.xor) 301 self.assertRaises(TypeError, operator.xor, None, None) 302 self.assertEqual(operator.xor(0xb, 0xc), 0x7) 303 304 def test_is(self): 305 operator = self.module 306 a = b = 'xyzpdq' 307 c = a[:3] + b[3:] 308 self.assertRaises(TypeError, operator.is_) 309 self.assertTrue(operator.is_(a, b)) 310 self.assertFalse(operator.is_(a,c)) 311 312 def test_is_not(self): 313 operator = self.module 314 a = b = 'xyzpdq' 315 c = a[:3] + b[3:] 316 self.assertRaises(TypeError, operator.is_not) 317 self.assertFalse(operator.is_not(a, b)) 318 self.assertTrue(operator.is_not(a,c)) 319 320 def test_attrgetter(self): 321 operator = self.module 322 class A: 323 pass 324 a = A() 325 a.name = 'arthur' 326 f = operator.attrgetter('name') 327 self.assertEqual(f(a), 'arthur') 328 self.assertRaises(TypeError, f) 329 self.assertRaises(TypeError, f, a, 'dent') 330 self.assertRaises(TypeError, f, a, surname='dent') 331 f = operator.attrgetter('rank') 332 self.assertRaises(AttributeError, f, a) 333 self.assertRaises(TypeError, operator.attrgetter, 2) 334 self.assertRaises(TypeError, operator.attrgetter) 335 336 # multiple gets 337 record = A() 338 record.x = 'X' 339 record.y = 'Y' 340 record.z = 'Z' 341 self.assertEqual(operator.attrgetter('x','z','y')(record), ('X', 'Z', 'Y')) 342 self.assertRaises(TypeError, operator.attrgetter, ('x', (), 'y')) 343 344 class C(object): 345 def __getattr__(self, name): 346 raise SyntaxError 347 self.assertRaises(SyntaxError, operator.attrgetter('foo'), C()) 348 349 # recursive gets 350 a = A() 351 a.name = 'arthur' 352 a.child = A() 353 a.child.name = 'thomas' 354 f = operator.attrgetter('child.name') 355 self.assertEqual(f(a), 'thomas') 356 self.assertRaises(AttributeError, f, a.child) 357 f = operator.attrgetter('name', 'child.name') 358 self.assertEqual(f(a), ('arthur', 'thomas')) 359 f = operator.attrgetter('name', 'child.name', 'child.child.name') 360 self.assertRaises(AttributeError, f, a) 361 f = operator.attrgetter('child.') 362 self.assertRaises(AttributeError, f, a) 363 f = operator.attrgetter('.child') 364 self.assertRaises(AttributeError, f, a) 365 366 a.child.child = A() 367 a.child.child.name = 'johnson' 368 f = operator.attrgetter('child.child.name') 369 self.assertEqual(f(a), 'johnson') 370 f = operator.attrgetter('name', 'child.name', 'child.child.name') 371 self.assertEqual(f(a), ('arthur', 'thomas', 'johnson')) 372 373 def test_itemgetter(self): 374 operator = self.module 375 a = 'ABCDE' 376 f = operator.itemgetter(2) 377 self.assertEqual(f(a), 'C') 378 self.assertRaises(TypeError, f) 379 self.assertRaises(TypeError, f, a, 3) 380 self.assertRaises(TypeError, f, a, size=3) 381 f = operator.itemgetter(10) 382 self.assertRaises(IndexError, f, a) 383 384 class C(object): 385 def __getitem__(self, name): 386 raise SyntaxError 387 self.assertRaises(SyntaxError, operator.itemgetter(42), C()) 388 389 f = operator.itemgetter('name') 390 self.assertRaises(TypeError, f, a) 391 self.assertRaises(TypeError, operator.itemgetter) 392 393 d = dict(key='val') 394 f = operator.itemgetter('key') 395 self.assertEqual(f(d), 'val') 396 f = operator.itemgetter('nonkey') 397 self.assertRaises(KeyError, f, d) 398 399 # example used in the docs 400 inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)] 401 getcount = operator.itemgetter(1) 402 self.assertEqual(list(map(getcount, inventory)), [3, 2, 5, 1]) 403 self.assertEqual(sorted(inventory, key=getcount), 404 [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]) 405 406 # multiple gets 407 data = list(map(str, range(20))) 408 self.assertEqual(operator.itemgetter(2,10,5)(data), ('2', '10', '5')) 409 self.assertRaises(TypeError, operator.itemgetter(2, 'x', 5), data) 410 411 # interesting indices 412 t = tuple('abcde') 413 self.assertEqual(operator.itemgetter(-1)(t), 'e') 414 self.assertEqual(operator.itemgetter(slice(2, 4))(t), ('c', 'd')) 415 416 # interesting sequences 417 class T(tuple): 418 'Tuple subclass' 419 pass 420 self.assertEqual(operator.itemgetter(0)(T('abc')), 'a') 421 self.assertEqual(operator.itemgetter(0)(['a', 'b', 'c']), 'a') 422 self.assertEqual(operator.itemgetter(0)(range(100, 200)), 100) 423 424 def test_methodcaller(self): 425 operator = self.module 426 self.assertRaises(TypeError, operator.methodcaller) 427 self.assertRaises(TypeError, operator.methodcaller, 12) 428 class A: 429 def foo(self, *args, **kwds): 430 return args[0] + args[1] 431 def bar(self, f=42): 432 return f 433 def baz(*args, **kwds): 434 return kwds['name'], kwds['self'] 435 a = A() 436 f = operator.methodcaller('foo') 437 self.assertRaises(IndexError, f, a) 438 f = operator.methodcaller('foo', 1, 2) 439 self.assertEqual(f(a), 3) 440 self.assertRaises(TypeError, f) 441 self.assertRaises(TypeError, f, a, 3) 442 self.assertRaises(TypeError, f, a, spam=3) 443 f = operator.methodcaller('bar') 444 self.assertEqual(f(a), 42) 445 self.assertRaises(TypeError, f, a, a) 446 f = operator.methodcaller('bar', f=5) 447 self.assertEqual(f(a), 5) 448 f = operator.methodcaller('baz', name='spam', self='eggs') 449 self.assertEqual(f(a), ('spam', 'eggs')) 450 451 def test_inplace(self): 452 operator = self.module 453 class C(object): 454 def __iadd__ (self, other): return "iadd" 455 def __iand__ (self, other): return "iand" 456 def __ifloordiv__(self, other): return "ifloordiv" 457 def __ilshift__ (self, other): return "ilshift" 458 def __imod__ (self, other): return "imod" 459 def __imul__ (self, other): return "imul" 460 def __imatmul__ (self, other): return "imatmul" 461 def __ior__ (self, other): return "ior" 462 def __ipow__ (self, other): return "ipow" 463 def __irshift__ (self, other): return "irshift" 464 def __isub__ (self, other): return "isub" 465 def __itruediv__ (self, other): return "itruediv" 466 def __ixor__ (self, other): return "ixor" 467 def __getitem__(self, other): return 5 # so that C is a sequence 468 c = C() 469 self.assertEqual(operator.iadd (c, 5), "iadd") 470 self.assertEqual(operator.iand (c, 5), "iand") 471 self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv") 472 self.assertEqual(operator.ilshift (c, 5), "ilshift") 473 self.assertEqual(operator.imod (c, 5), "imod") 474 self.assertEqual(operator.imul (c, 5), "imul") 475 self.assertEqual(operator.imatmul (c, 5), "imatmul") 476 self.assertEqual(operator.ior (c, 5), "ior") 477 self.assertEqual(operator.ipow (c, 5), "ipow") 478 self.assertEqual(operator.irshift (c, 5), "irshift") 479 self.assertEqual(operator.isub (c, 5), "isub") 480 self.assertEqual(operator.itruediv (c, 5), "itruediv") 481 self.assertEqual(operator.ixor (c, 5), "ixor") 482 self.assertEqual(operator.iconcat (c, c), "iadd") 483 484 def test_length_hint(self): 485 operator = self.module 486 class X(object): 487 def __init__(self, value): 488 self.value = value 489 490 def __length_hint__(self): 491 if type(self.value) is type: 492 raise self.value 493 else: 494 return self.value 495 496 self.assertEqual(operator.length_hint([], 2), 0) 497 self.assertEqual(operator.length_hint(iter([1, 2, 3])), 3) 498 499 self.assertEqual(operator.length_hint(X(2)), 2) 500 self.assertEqual(operator.length_hint(X(NotImplemented), 4), 4) 501 self.assertEqual(operator.length_hint(X(TypeError), 12), 12) 502 with self.assertRaises(TypeError): 503 operator.length_hint(X("abc")) 504 with self.assertRaises(ValueError): 505 operator.length_hint(X(-2)) 506 with self.assertRaises(LookupError): 507 operator.length_hint(X(LookupError)) 508 509 def test_dunder_is_original(self): 510 operator = self.module 511 512 names = [name for name in dir(operator) if not name.startswith('_')] 513 for name in names: 514 orig = getattr(operator, name) 515 dunder = getattr(operator, '__' + name.strip('_') + '__', None) 516 if dunder: 517 self.assertIs(dunder, orig) 518 519class PyOperatorTestCase(OperatorTestCase, unittest.TestCase): 520 module = py_operator 521 522@unittest.skipUnless(c_operator, 'requires _operator') 523class COperatorTestCase(OperatorTestCase, unittest.TestCase): 524 module = c_operator 525 526 527class OperatorPickleTestCase: 528 def copy(self, obj, proto): 529 with support.swap_item(sys.modules, 'operator', self.module): 530 pickled = pickle.dumps(obj, proto) 531 with support.swap_item(sys.modules, 'operator', self.module2): 532 return pickle.loads(pickled) 533 534 def test_attrgetter(self): 535 attrgetter = self.module.attrgetter 536 class A: 537 pass 538 a = A() 539 a.x = 'X' 540 a.y = 'Y' 541 a.z = 'Z' 542 a.t = A() 543 a.t.u = A() 544 a.t.u.v = 'V' 545 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 546 with self.subTest(proto=proto): 547 f = attrgetter('x') 548 f2 = self.copy(f, proto) 549 self.assertEqual(repr(f2), repr(f)) 550 self.assertEqual(f2(a), f(a)) 551 # multiple gets 552 f = attrgetter('x', 'y', 'z') 553 f2 = self.copy(f, proto) 554 self.assertEqual(repr(f2), repr(f)) 555 self.assertEqual(f2(a), f(a)) 556 # recursive gets 557 f = attrgetter('t.u.v') 558 f2 = self.copy(f, proto) 559 self.assertEqual(repr(f2), repr(f)) 560 self.assertEqual(f2(a), f(a)) 561 562 def test_itemgetter(self): 563 itemgetter = self.module.itemgetter 564 a = 'ABCDE' 565 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 566 with self.subTest(proto=proto): 567 f = itemgetter(2) 568 f2 = self.copy(f, proto) 569 self.assertEqual(repr(f2), repr(f)) 570 self.assertEqual(f2(a), f(a)) 571 # multiple gets 572 f = itemgetter(2, 0, 4) 573 f2 = self.copy(f, proto) 574 self.assertEqual(repr(f2), repr(f)) 575 self.assertEqual(f2(a), f(a)) 576 577 def test_methodcaller(self): 578 methodcaller = self.module.methodcaller 579 class A: 580 def foo(self, *args, **kwds): 581 return args[0] + args[1] 582 def bar(self, f=42): 583 return f 584 def baz(*args, **kwds): 585 return kwds['name'], kwds['self'] 586 a = A() 587 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 588 with self.subTest(proto=proto): 589 f = methodcaller('bar') 590 f2 = self.copy(f, proto) 591 self.assertEqual(repr(f2), repr(f)) 592 self.assertEqual(f2(a), f(a)) 593 # positional args 594 f = methodcaller('foo', 1, 2) 595 f2 = self.copy(f, proto) 596 self.assertEqual(repr(f2), repr(f)) 597 self.assertEqual(f2(a), f(a)) 598 # keyword args 599 f = methodcaller('bar', f=5) 600 f2 = self.copy(f, proto) 601 self.assertEqual(repr(f2), repr(f)) 602 self.assertEqual(f2(a), f(a)) 603 f = methodcaller('baz', self='eggs', name='spam') 604 f2 = self.copy(f, proto) 605 # Can't test repr consistently with multiple keyword args 606 self.assertEqual(f2(a), f(a)) 607 608class PyPyOperatorPickleTestCase(OperatorPickleTestCase, unittest.TestCase): 609 module = py_operator 610 module2 = py_operator 611 612@unittest.skipUnless(c_operator, 'requires _operator') 613class PyCOperatorPickleTestCase(OperatorPickleTestCase, unittest.TestCase): 614 module = py_operator 615 module2 = c_operator 616 617@unittest.skipUnless(c_operator, 'requires _operator') 618class CPyOperatorPickleTestCase(OperatorPickleTestCase, unittest.TestCase): 619 module = c_operator 620 module2 = py_operator 621 622@unittest.skipUnless(c_operator, 'requires _operator') 623class CCOperatorPickleTestCase(OperatorPickleTestCase, unittest.TestCase): 624 module = c_operator 625 module2 = c_operator 626 627 628if __name__ == "__main__": 629 unittest.main() 630