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