← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python3.4/trusty-proposed

« back to all changes in this revision

Viewing changes to Lib/test/test_operator.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-11-25 09:44:27 UTC
  • Revision ID: package-import@ubuntu.com-20131125094427-lzxj8ap5w01lmo7f
Tags: upstream-3.4~b1
Import upstream version 3.4~b1

Show diffs side-by-side

added added

removed removed

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