Lines Matching refs:self

15     def __init__(self, lst):
16 self.lst = lst
17 def __len__(self):
18 return len(self.lst)
19 def __getitem__(self, i):
20 return self.lst[i]
21 def __add__(self, other):
22 return self.lst + other.lst
23 def __mul__(self, other):
24 return self.lst * other
25 def __rmul__(self, other):
26 return other * self.lst
29 def __init__(self, lst):
30 self.lst = lst
31 def __len__(self):
32 return len(self.lst)
33 def __getitem__(self, i):
34 return self.lst[i]
35 def __add__(self, other):
36 return self.lst + other.lst
37 def __mul__(self, other):
38 return self.lst * other
39 def __rmul__(self, other):
40 return other * self.lst
43 def __iter__(self):
48 def test___all__(self):
49 operator = self.module
58 self.assertSetEqual(computed_all, actual_all)
60 def test_lt(self):
61 operator = self.module
62 self.assertRaises(TypeError, operator.lt)
63 self.assertRaises(TypeError, operator.lt, 1j, 2j)
64 self.assertFalse(operator.lt(1, 0))
65 self.assertFalse(operator.lt(1, 0.0))
66 self.assertFalse(operator.lt(1, 1))
67 self.assertFalse(operator.lt(1, 1.0))
68 self.assertTrue(operator.lt(1, 2))
69 self.assertTrue(operator.lt(1, 2.0))
71 def test_le(self):
72 operator = self.module
73 self.assertRaises(TypeError, operator.le)
74 self.assertRaises(TypeError, operator.le, 1j, 2j)
75 self.assertFalse(operator.le(1, 0))
76 self.assertFalse(operator.le(1, 0.0))
77 self.assertTrue(operator.le(1, 1))
78 self.assertTrue(operator.le(1, 1.0))
79 self.assertTrue(operator.le(1, 2))
80 self.assertTrue(operator.le(1, 2.0))
82 def test_eq(self):
83 operator = self.module
85 def __eq__(self, other):
87 self.assertRaises(TypeError, operator.eq)
88 self.assertRaises(SyntaxError, operator.eq, C(), C())
89 self.assertFalse(operator.eq(1, 0))
90 self.assertFalse(operator.eq(1, 0.0))
91 self.assertTrue(operator.eq(1, 1))
92 self.assertTrue(operator.eq(1, 1.0))
93 self.assertFalse(operator.eq(1, 2))
94 self.assertFalse(operator.eq(1, 2.0))
96 def test_ne(self):
97 operator = self.module
99 def __ne__(self, other):
101 self.assertRaises(TypeError, operator.ne)
102 self.assertRaises(SyntaxError, operator.ne, C(), C())
103 self.assertTrue(operator.ne(1, 0))
104 self.assertTrue(operator.ne(1, 0.0))
105 self.assertFalse(operator.ne(1, 1))
106 self.assertFalse(operator.ne(1, 1.0))
107 self.assertTrue(operator.ne(1, 2))
108 self.assertTrue(operator.ne(1, 2.0))
110 def test_ge(self):
111 operator = self.module
112 self.assertRaises(TypeError, operator.ge)
113 self.assertRaises(TypeError, operator.ge, 1j, 2j)
114 self.assertTrue(operator.ge(1, 0))
115 self.assertTrue(operator.ge(1, 0.0))
116 self.assertTrue(operator.ge(1, 1))
117 self.assertTrue(operator.ge(1, 1.0))
118 self.assertFalse(operator.ge(1, 2))
119 self.assertFalse(operator.ge(1, 2.0))
121 def test_gt(self):
122 operator = self.module
123 self.assertRaises(TypeError, operator.gt)
124 self.assertRaises(TypeError, operator.gt, 1j, 2j)
125 self.assertTrue(operator.gt(1, 0))
126 self.assertTrue(operator.gt(1, 0.0))
127 self.assertFalse(operator.gt(1, 1))
128 self.assertFalse(operator.gt(1, 1.0))
129 self.assertFalse(operator.gt(1, 2))
130 self.assertFalse(operator.gt(1, 2.0))
132 def test_abs(self):
133 operator = self.module
134 self.assertRaises(TypeError, operator.abs)
135 self.assertRaises(TypeError, operator.abs, None)
136 self.assertEqual(operator.abs(-1), 1)
137 self.assertEqual(operator.abs(1), 1)
139 def test_add(self):
140 operator = self.module
141 self.assertRaises(TypeError, operator.add)
142 self.assertRaises(TypeError, operator.add, None, None)
143 self.assertEqual(operator.add(3, 4), 7)
145 def test_bitwise_and(self):
146 operator = self.module
147 self.assertRaises(TypeError, operator.and_)
148 self.assertRaises(TypeError, operator.and_, None, None)
149 self.assertEqual(operator.and_(0xf, 0xa), 0xa)
151 def test_concat(self):
152 operator = self.module
153 self.assertRaises(TypeError, operator.concat)
154 self.assertRaises(TypeError, operator.concat, None, None)
155 self.assertEqual(operator.concat('py', 'thon'), 'python')
156 self.assertEqual(operator.concat([1, 2], [3, 4]), [1, 2, 3, 4])
157 self.assertEqual(operator.concat(Seq1([5, 6]), Seq1([7])), [5, 6, 7])
158 self.assertEqual(operator.concat(Seq2([5, 6]), Seq2([7])), [5, 6, 7])
159 self.assertRaises(TypeError, operator.concat, 13, 29)
161 def test_countOf(self):
162 operator = self.module
163 self.assertRaises(TypeError, operator.countOf)
164 self.assertRaises(TypeError, operator.countOf, None, None)
165 self.assertRaises(ZeroDivisionError, operator.countOf, BadIterable(), 1)
166 self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 3), 1)
167 self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 5), 0)
170 self.assertEqual(operator.countOf([nan, nan, 21], nan), 2)
172 self.assertEqual(operator.countOf([{}, 1, {}, 2], {}), 2)
174 def test_delitem(self):
175 operator = self.module
177 self.assertRaises(TypeError, operator.delitem, a)
178 self.assertRaises(TypeError, operator.delitem, a, None)
179 self.assertIsNone(operator.delitem(a, 1))
180 self.assertEqual(a, [4, 2, 1])
182 def test_floordiv(self):
183 operator = self.module
184 self.assertRaises(TypeError, operator.floordiv, 5)
185 self.assertRaises(TypeError, operator.floordiv, None, None)
186 self.assertEqual(operator.floordiv(5, 2), 2)
188 def test_truediv(self):
189 operator = self.module
190 self.assertRaises(TypeError, operator.truediv, 5)
191 self.assertRaises(TypeError, operator.truediv, None, None)
192 self.assertEqual(operator.truediv(5, 2), 2.5)
194 def test_getitem(self):
195 operator = self.module
197 self.assertRaises(TypeError, operator.getitem)
198 self.assertRaises(TypeError, operator.getitem, a, None)
199 self.assertEqual(operator.getitem(a, 2), 2)
201 def test_indexOf(self):
202 operator = self.module
203 self.assertRaises(TypeError, operator.indexOf)
204 self.assertRaises(TypeError, operator.indexOf, None, None)
205 self.assertRaises(ZeroDivisionError, operator.indexOf, BadIterable(), 1)
206 self.assertEqual(operator.indexOf([4, 3, 2, 1], 3), 1)
207 self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0)
209 self.assertEqual(operator.indexOf([nan, nan, 21], nan), 0)
210 self.assertEqual(operator.indexOf([{}, 1, {}, 2], {}), 0)
212 self.assertEqual(operator.indexOf(it, 'a'), 2)
213 self.assertEqual(next(it), 'v')
215 def test_invert(self):
216 operator = self.module
217 self.assertRaises(TypeError, operator.invert)
218 self.assertRaises(TypeError, operator.invert, None)
219 self.assertEqual(operator.inv(4), -5)
221 def test_lshift(self):
222 operator = self.module
223 self.assertRaises(TypeError, operator.lshift)
224 self.assertRaises(TypeError, operator.lshift, None, 42)
225 self.assertEqual(operator.lshift(5, 1), 10)
226 self.assertEqual(operator.lshift(5, 0), 5)
227 self.assertRaises(ValueError, operator.lshift, 2, -1)
229 def test_mod(self):
230 operator = self.module
231 self.assertRaises(TypeError, operator.mod)
232 self.assertRaises(TypeError, operator.mod, None, 42)
233 self.assertEqual(operator.mod(5, 2), 1)
235 def test_mul(self):
236 operator = self.module
237 self.assertRaises(TypeError, operator.mul)
238 self.assertRaises(TypeError, operator.mul, None, None)
239 self.assertEqual(operator.mul(5, 2), 10)
241 def test_matmul(self):
242 operator = self.module
243 self.assertRaises(TypeError, operator.matmul)
244 self.assertRaises(TypeError, operator.matmul, 42, 42)
246 def __matmul__(self, other):
248 self.assertEqual(M() @ 42, 41)
250 def test_neg(self):
251 operator = self.module
252 self.assertRaises(TypeError, operator.neg)
253 self.assertRaises(TypeError, operator.neg, None)
254 self.assertEqual(operator.neg(5), -5)
255 self.assertEqual(operator.neg(-5), 5)
256 self.assertEqual(operator.neg(0), 0)
257 self.assertEqual(operator.neg(-0), 0)
259 def test_bitwise_or(self):
260 operator = self.module
261 self.assertRaises(TypeError, operator.or_)
262 self.assertRaises(TypeError, operator.or_, None, None)
263 self.assertEqual(operator.or_(0xa, 0x5), 0xf)
265 def test_pos(self):
266 operator = self.module
267 self.assertRaises(TypeError, operator.pos)
268 self.assertRaises(TypeError, operator.pos, None)
269 self.assertEqual(operator.pos(5), 5)
270 self.assertEqual(operator.pos(-5), -5)
271 self.assertEqual(operator.pos(0), 0)
272 self.assertEqual(operator.pos(-0), 0)
274 def test_pow(self):
275 operator = self.module
276 self.assertRaises(TypeError, operator.pow)
277 self.assertRaises(TypeError, operator.pow, None, None)
278 self.assertEqual(operator.pow(3,5), 3**5)
279 self.assertRaises(TypeError, operator.pow, 1)
280 self.assertRaises(TypeError, operator.pow, 1, 2, 3)
282 def test_rshift(self):
283 operator = self.module
284 self.assertRaises(TypeError, operator.rshift)
285 self.assertRaises(TypeError, operator.rshift, None, 42)
286 self.assertEqual(operator.rshift(5, 1), 2)
287 self.assertEqual(operator.rshift(5, 0), 5)
288 self.assertRaises(ValueError, operator.rshift, 2, -1)
290 def test_contains(self):
291 operator = self.module
292 self.assertRaises(TypeError, operator.contains)
293 self.assertRaises(TypeError, operator.contains, None, None)
294 self.assertRaises(ZeroDivisionError, operator.contains, BadIterable(), 1)
295 self.assertTrue(operator.contains(range(4), 2))
296 self.assertFalse(operator.contains(range(4), 5))
298 def test_setitem(self):
299 operator = self.module
301 self.assertRaises(TypeError, operator.setitem, a)
302 self.assertRaises(TypeError, operator.setitem, a, None, None)
303 self.assertIsNone(operator.setitem(a, 0, 2))
304 self.assertEqual(a, [2, 1, 2])
305 self.assertRaises(IndexError, operator.setitem, a, 4, 2)
307 def test_sub(self):
308 operator = self.module
309 self.assertRaises(TypeError, operator.sub)
310 self.assertRaises(TypeError, operator.sub, None, None)
311 self.assertEqual(operator.sub(5, 2), 3)
313 def test_truth(self):
314 operator = self.module
316 def __bool__(self):
318 self.assertRaises(TypeError, operator.truth)
319 self.assertRaises(SyntaxError, operator.truth, C())
320 self.assertTrue(operator.truth(5))
321 self.assertTrue(operator.truth([0]))
322 self.assertFalse(operator.truth(0))
323 self.assertFalse(operator.truth([]))
325 def test_bitwise_xor(self):
326 operator = self.module
327 self.assertRaises(TypeError, operator.xor)
328 self.assertRaises(TypeError, operator.xor, None, None)
329 self.assertEqual(operator.xor(0xb, 0xc), 0x7)
331 def test_is(self):
332 operator = self.module
335 self.assertRaises(TypeError, operator.is_)
336 self.assertTrue(operator.is_(a, b))
337 self.assertFalse(operator.is_(a,c))
339 def test_is_not(self):
340 operator = self.module
343 self.assertRaises(TypeError, operator.is_not)
344 self.assertFalse(operator.is_not(a, b))
345 self.assertTrue(operator.is_not(a,c))
347 def test_attrgetter(self):
348 operator = self.module
354 self.assertEqual(f(a), 'arthur')
355 self.assertRaises(TypeError, f)
356 self.assertRaises(TypeError, f, a, 'dent')
357 self.assertRaises(TypeError, f, a, surname='dent')
359 self.assertRaises(AttributeError, f, a)
360 self.assertRaises(TypeError, operator.attrgetter, 2)
361 self.assertRaises(TypeError, operator.attrgetter)
368 self.assertEqual(operator.attrgetter('x','z','y')(record), ('X', 'Z', 'Y'))
369 self.assertRaises(TypeError, operator.attrgetter, ('x', (), 'y'))
372 def __getattr__(self, name):
374 self.assertRaises(SyntaxError, operator.attrgetter('foo'), C())
382 self.assertEqual(f(a), 'thomas')
383 self.assertRaises(AttributeError, f, a.child)
385 self.assertEqual(f(a), ('arthur', 'thomas'))
387 self.assertRaises(AttributeError, f, a)
389 self.assertRaises(AttributeError, f, a)
391 self.assertRaises(AttributeError, f, a)
396 self.assertEqual(f(a), 'johnson')
398 self.assertEqual(f(a), ('arthur', 'thomas', 'johnson'))
400 def test_itemgetter(self):
401 operator = self.module
404 self.assertEqual(f(a), 'C')
405 self.assertRaises(TypeError, f)
406 self.assertRaises(TypeError, f, a, 3)
407 self.assertRaises(TypeError, f, a, size=3)
409 self.assertRaises(IndexError, f, a)
412 def __getitem__(self, name):
414 self.assertRaises(SyntaxError, operator.itemgetter(42), C())
417 self.assertRaises(TypeError, f, a)
418 self.assertRaises(TypeError, operator.itemgetter)
422 self.assertEqual(f(d), 'val')
424 self.assertRaises(KeyError, f, d)
429 self.assertEqual(list(map(getcount, inventory)), [3, 2, 5, 1])
430 self.assertEqual(sorted(inventory, key=getcount),
435 self.assertEqual(operator.itemgetter(2,10,5)(data), ('2', '10', '5'))
436 self.assertRaises(TypeError, operator.itemgetter(2, 'x', 5), data)
440 self.assertEqual(operator.itemgetter(-1)(t), 'e')
441 self.assertEqual(operator.itemgetter(slice(2, 4))(t), ('c', 'd'))
447 self.assertEqual(operator.itemgetter(0)(T('abc')), 'a')
448 self.assertEqual(operator.itemgetter(0)(['a', 'b', 'c']), 'a')
449 self.assertEqual(operator.itemgetter(0)(range(100, 200)), 100)
451 def test_methodcaller(self):
452 operator = self.module
453 self.assertRaises(TypeError, operator.methodcaller)
454 self.assertRaises(TypeError, operator.methodcaller, 12)
456 def foo(self, *args, **kwds):
458 def bar(self, f=42):
461 return kwds['name'], kwds['self']
464 self.assertRaises(IndexError, f, a)
466 self.assertEqual(f(a), 3)
467 self.assertRaises(TypeError, f)
468 self.assertRaises(TypeError, f, a, 3)
469 self.assertRaises(TypeError, f, a, spam=3)
471 self.assertEqual(f(a), 42)
472 self.assertRaises(TypeError, f, a, a)
474 self.assertEqual(f(a), 5)
475 f = operator.methodcaller('baz', name='spam', self='eggs')
476 self.assertEqual(f(a), ('spam', 'eggs'))
478 def test_inplace(self):
479 operator = self.module
481 def __iadd__ (self, other): return "iadd"
482 def __iand__ (self, other): return "iand"
483 def __ifloordiv__(self, other): return "ifloordiv"
484 def __ilshift__ (self, other): return "ilshift"
485 def __imod__ (self, other): return "imod"
486 def __imul__ (self, other): return "imul"
487 def __imatmul__ (self, other): return "imatmul"
488 def __ior__ (self, other): return "ior"
489 def __ipow__ (self, other): return "ipow"
490 def __irshift__ (self, other): return "irshift"
491 def __isub__ (self, other): return "isub"
492 def __itruediv__ (self, other): return "itruediv"
493 def __ixor__ (self, other): return "ixor"
494 def __getitem__(self, other): return 5 # so that C is a sequence
496 self.assertEqual(operator.iadd (c, 5), "iadd")
497 self.assertEqual(operator.iand (c, 5), "iand")
498 self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv")
499 self.assertEqual(operator.ilshift (c, 5), "ilshift")
500 self.assertEqual(operator.imod (c, 5), "imod")
501 self.assertEqual(operator.imul (c, 5), "imul")
502 self.assertEqual(operator.imatmul (c, 5), "imatmul")
503 self.assertEqual(operator.ior (c, 5), "ior")
504 self.assertEqual(operator.ipow (c, 5), "ipow")
505 self.assertEqual(operator.irshift (c, 5), "irshift")
506 self.assertEqual(operator.isub (c, 5), "isub")
507 self.assertEqual(operator.itruediv (c, 5), "itruediv")
508 self.assertEqual(operator.ixor (c, 5), "ixor")
509 self.assertEqual(operator.iconcat (c, c), "iadd")
511 def test_length_hint(self):
512 operator = self.module
514 def __init__(self, value):
515 self.value = value
517 def __length_hint__(self):
518 if type(self.value) is type:
519 raise self.value
521 return self.value
523 self.assertEqual(operator.length_hint([], 2), 0)
524 self.assertEqual(operator.length_hint(iter([1, 2, 3])), 3)
526 self.assertEqual(operator.length_hint(X(2)), 2)
527 self.assertEqual(operator.length_hint(X(NotImplemented), 4), 4)
528 self.assertEqual(operator.length_hint(X(TypeError), 12), 12)
529 with self.assertRaises(TypeError):
531 with self.assertRaises(ValueError):
533 with self.assertRaises(LookupError):
536 def test_call(self):
537 operator = self.module
541 self.assertEqual(operator.call(func), ((), {}))
542 self.assertEqual(operator.call(func, 0, 1), ((0, 1), {}))
543 self.assertEqual(operator.call(func, a=2, obj=3),
545 self.assertEqual(operator.call(func, 0, 1, a=2, obj=3),
548 def test_dunder_is_original(self):
549 operator = self.module
556 self.assertIs(dunder, orig)
567 def copy(self, obj, proto):
568 with support.swap_item(sys.modules, 'operator', self.module):
570 with support.swap_item(sys.modules, 'operator', self.module2):
573 def test_attrgetter(self):
574 attrgetter = self.module.attrgetter
585 with self.subTest(proto=proto):
587 f2 = self.copy(f, proto)
588 self.assertEqual(repr(f2), repr(f))
589 self.assertEqual(f2(a), f(a))
592 f2 = self.copy(f, proto)
593 self.assertEqual(repr(f2), repr(f))
594 self.assertEqual(f2(a), f(a))
597 f2 = self.copy(f, proto)
598 self.assertEqual(repr(f2), repr(f))
599 self.assertEqual(f2(a), f(a))
601 def test_itemgetter(self):
602 itemgetter = self.module.itemgetter
605 with self.subTest(proto=proto):
607 f2 = self.copy(f, proto)
608 self.assertEqual(repr(f2), repr(f))
609 self.assertEqual(f2(a), f(a))
612 f2 = self.copy(f, proto)
613 self.assertEqual(repr(f2), repr(f))
614 self.assertEqual(f2(a), f(a))
616 def test_methodcaller(self):
617 methodcaller = self.module.methodcaller
619 def foo(self, *args, **kwds):
621 def bar(self, f=42):
624 return kwds['name'], kwds['self']
627 with self.subTest(proto=proto):
629 f2 = self.copy(f, proto)
630 self.assertEqual(repr(f2), repr(f))
631 self.assertEqual(f2(a), f(a))
634 f2 = self.copy(f, proto)
635 self.assertEqual(repr(f2), repr(f))
636 self.assertEqual(f2(a), f(a))
639 f2 = self.copy(f, proto)
640 self.assertEqual(repr(f2), repr(f))
641 self.assertEqual(f2(a), f(a))
642 f = methodcaller('baz', self='eggs', name='spam')
643 f2 = self.copy(f, proto)
645 self.assertEqual(f2(a), f(a))