Debian Codegraph @

Lib/test/test_operator.py

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