Lib/test/test_operator.py

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