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.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             self.assertTrue(operator.isCallable(o) == callable(o) == v)
 196         check(self, 4, 0)
 197         check(self, operator.isCallable, 1)
 198         check(self, C, 1)
 199         check(self, C(), 0)
 200
 201     def test_isMappingType(self):
 202         self.assertRaises(TypeError, operator.isMappingType)
 203         self.assertFalse(operator.isMappingType(1))
 204         self.assertFalse(operator.isMappingType(operator.isMappingType))
 205         self.assertTrue(operator.isMappingType(operator.__dict__))
 206         self.assertTrue(operator.isMappingType({}))
 207
 208     def test_isNumberType(self):
 209         self.assertRaises(TypeError, operator.isNumberType)
 210         self.assertTrue(operator.isNumberType(8))
 211         self.assertTrue(operator.isNumberType(8j))
 212         self.assertTrue(operator.isNumberType(8L))
 213         self.assertTrue(operator.isNumberType(8.3))
 214         self.assertFalse(operator.isNumberType(dir()))
 215
 216     def test_isSequenceType(self):
 217         self.assertRaises(TypeError, operator.isSequenceType)
 218         self.assertTrue(operator.isSequenceType(dir()))
 219         self.assertTrue(operator.isSequenceType(()))
 220         self.assertTrue(operator.isSequenceType(xrange(10)))
 221         self.assertTrue(operator.isSequenceType('yeahbuddy'))
 222         self.assertFalse(operator.isSequenceType(3))
 223         class Dict(dict): pass
 224         self.assertFalse(operator.isSequenceType(Dict()))
 225
 226     def test_lshift(self):
 227         self.assertRaises(TypeError, operator.lshift)
 228         self.assertRaises(TypeError, operator.lshift, None, 42)
 229         self.assertTrue(operator.lshift(5, 1) == 10)
 230         self.assertTrue(operator.lshift(5, 0) == 5)
 231         self.assertRaises(ValueError, operator.lshift, 2, -1)
 232
 233     def test_mod(self):
 234         self.assertRaises(TypeError, operator.mod)
 235         self.assertRaises(TypeError, operator.mod, None, 42)
 236         self.assertTrue(operator.mod(5, 2) == 1)
 237
 238     def test_mul(self):
 239         self.assertRaises(TypeError, operator.mul)
 240         self.assertRaises(TypeError, operator.mul, None, None)
 241         self.assertTrue(operator.mul(5, 2) == 10)
 242
 243     def test_neg(self):
 244         self.assertRaises(TypeError, operator.neg)
 245         self.assertRaises(TypeError, operator.neg, None)
 246         self.assertTrue(operator.neg(5) == -5)
 247         self.assertTrue(operator.neg(-5) == 5)
 248         self.assertTrue(operator.neg(0) == 0)
 249         self.assertTrue(operator.neg(-0) == 0)
 250
 251     def test_bitwise_or(self):
 252         self.assertRaises(TypeError, operator.or_)
 253         self.assertRaises(TypeError, operator.or_, None, None)
 254         self.assertTrue(operator.or_(0xa, 0x5) == 0xf)
 255
 256     def test_pos(self):
 257         self.assertRaises(TypeError, operator.pos)
 258         self.assertRaises(TypeError, operator.pos, None)
 259         self.assertTrue(operator.pos(5) == 5)
 260         self.assertTrue(operator.pos(-5) == -5)
 261         self.assertTrue(operator.pos(0) == 0)
 262         self.assertTrue(operator.pos(-0) == 0)
 263
 264     def test_pow(self):
 265         self.assertRaises(TypeError, operator.pow)
 266         self.assertRaises(TypeError, operator.pow, None, None)
 267         self.assertTrue(operator.pow(3,5) == 3**5)
 268         self.assertTrue(operator.__pow__(3,5) == 3**5)
 269         self.assertRaises(TypeError, operator.pow, 1)
 270         self.assertRaises(TypeError, operator.pow, 1, 2, 3)
 271
 272     def test_repeat(self):
 273         a = range(3)
 274         self.assertRaises(TypeError, operator.repeat)
 275         self.assertRaises(TypeError, operator.repeat, a, None)
 276         self.assertTrue(operator.repeat(a, 2) == a+a)
 277         self.assertTrue(operator.repeat(a, 1) == a)
 278         self.assertTrue(operator.repeat(a, 0) == [])
 279         a = (1, 2, 3)
 280         self.assertTrue(operator.repeat(a, 2) == a+a)
 281         self.assertTrue(operator.repeat(a, 1) == a)
 282         self.assertTrue(operator.repeat(a, 0) == ())
 283         a = '123'
 284         self.assertTrue(operator.repeat(a, 2) == a+a)
 285         self.assertTrue(operator.repeat(a, 1) == a)
 286         self.assertTrue(operator.repeat(a, 0) == '')
 287         a = Seq1([4, 5, 6])
 288         self.assertTrue(operator.repeat(a, 2) == [4, 5, 6, 4, 5, 6])
 289         self.assertTrue(operator.repeat(a, 1) == [4, 5, 6])
 290         self.assertTrue(operator.repeat(a, 0) == [])
 291         a = Seq2([4, 5, 6])
 292         self.assertTrue(operator.repeat(a, 2) == [4, 5, 6, 4, 5, 6])
 293         self.assertTrue(operator.repeat(a, 1) == [4, 5, 6])
 294         self.assertTrue(operator.repeat(a, 0) == [])
 295         self.assertRaises(TypeError, operator.repeat, 6, 7)
 296
 297     def test_rshift(self):
 298         self.assertRaises(TypeError, operator.rshift)
 299         self.assertRaises(TypeError, operator.rshift, None, 42)
 300         self.assertTrue(operator.rshift(5, 1) == 2)
 301         self.assertTrue(operator.rshift(5, 0) == 5)
 302         self.assertRaises(ValueError, operator.rshift, 2, -1)
 303
 304     def test_contains(self):
 305         self.assertRaises(TypeError, operator.contains)
 306         self.assertRaises(TypeError, operator.contains, None, None)
 307         self.assertTrue(operator.contains(range(4), 2))
 308         self.assertFalse(operator.contains(range(4), 5))
 309         self.assertTrue(operator.sequenceIncludes(range(4), 2))
 310         self.assertFalse(operator.sequenceIncludes(range(4), 5))
 311
 312     def test_setitem(self):
 313         a = range(3)
 314         self.assertRaises(TypeError, operator.setitem, a)
 315         self.assertRaises(TypeError, operator.setitem, a, None, None)
 316         self.assertTrue(operator.setitem(a, 0, 2) is None)
 317         self.assertTrue(a == [2, 1, 2])
 318         self.assertRaises(IndexError, operator.setitem, a, 4, 2)
 319
 320     def test_setslice(self):
 321         a = range(4)
 322         self.assertRaises(TypeError, operator.setslice, a)
 323         self.assertRaises(TypeError, operator.setslice, a, None, None, None)
 324         self.assertTrue(operator.setslice(a, 1, 3, [2, 1]) is None)
 325         self.assertTrue(a == [0, 2, 1, 3])
 326         operator.setslice(a, 0, test_support.MAX_Py_ssize_t, [])
 327         self.assertTrue(a == [])
 328
 329     def test_sub(self):
 330         self.assertRaises(TypeError, operator.sub)
 331         self.assertRaises(TypeError, operator.sub, None, None)
 332         self.assertTrue(operator.sub(5, 2) == 3)
 333
 334     def test_truth(self):
 335         class C(object):
 336             def __nonzero__(self):
 337                 raise SyntaxError
 338         self.assertRaises(TypeError, operator.truth)
 339         self.assertRaises(SyntaxError, operator.truth, C())
 340         self.assertTrue(operator.truth(5))
 341         self.assertTrue(operator.truth([0]))
 342         self.assertFalse(operator.truth(0))
 343         self.assertFalse(operator.truth([]))
 344
 345     def test_bitwise_xor(self):
 346         self.assertRaises(TypeError, operator.xor)
 347         self.assertRaises(TypeError, operator.xor, None, None)
 348         self.assertTrue(operator.xor(0xb, 0xc) == 0x7)
 349
 350     def test_is(self):
 351         a = b = 'xyzpdq'
 352         c = a[:3] + b[3:]
 353         self.assertRaises(TypeError, operator.is_)
 354         self.assertTrue(operator.is_(a, b))
 355         self.assertFalse(operator.is_(a,c))
 356
 357     def test_is_not(self):
 358         a = b = 'xyzpdq'
 359         c = a[:3] + b[3:]
 360         self.assertRaises(TypeError, operator.is_not)
 361         self.assertFalse(operator.is_not(a, b))
 362         self.assertTrue(operator.is_not(a,c))
 363
 364     def test_attrgetter(self):
 365         class A:
 366             pass
 367         a = A()
 368         a.name = 'arthur'
 369         f = operator.attrgetter('name')
 370         self.assertEqual(f(a), 'arthur')
 371         f = operator.attrgetter('rank')
 372         self.assertRaises(AttributeError, f, a)
 373         f = operator.attrgetter(2)
 374         self.assertRaises(TypeError, f, a)
 375         self.assertRaises(TypeError, operator.attrgetter)
 376
 377         # multiple gets
 378         record = A()
 379         record.x = 'X'
 380         record.y = 'Y'
 381         record.z = 'Z'
 382         self.assertEqual(operator.attrgetter('x','z','y')(record), ('X', 'Z', 'Y'))
 383         self.assertRaises(TypeError, operator.attrgetter('x', (), 'y'), record)
 384
 385         class C(object):
 386             def __getattr__(self, name):
 387                 raise SyntaxError
 388         self.assertRaises(SyntaxError, operator.attrgetter('foo'), C())
 389
 390         # recursive gets
 391         a = A()
 392         a.name = 'arthur'
 393         a.child = A()
 394         a.child.name = 'thomas'
 395         f = operator.attrgetter('child.name')
 396         self.assertEqual(f(a), 'thomas')
 397         self.assertRaises(AttributeError, f, a.child)
 398         f = operator.attrgetter('name', 'child.name')
 399         self.assertEqual(f(a), ('arthur', 'thomas'))
 400         f = operator.attrgetter('name', 'child.name', 'child.child.name')
 401         self.assertRaises(AttributeError, f, a)
 402
 403         a.child.child = A()
 404         a.child.child.name = 'johnson'
 405         f = operator.attrgetter('child.child.name')
 406         self.assertEqual(f(a), 'johnson')
 407         f = operator.attrgetter('name', 'child.name', 'child.child.name')
 408         self.assertEqual(f(a), ('arthur', 'thomas', 'johnson'))
 409
 410     def test_itemgetter(self):
 411         a = 'ABCDE'
 412         f = operator.itemgetter(2)
 413         self.assertEqual(f(a), 'C')
 414         f = operator.itemgetter(10)
 415         self.assertRaises(IndexError, f, a)
 416
 417         class C(object):
 418             def __getitem__(self, name):
 419                 raise SyntaxError
 420         self.assertRaises(SyntaxError, operator.itemgetter(42), C())
 421
 422         f = operator.itemgetter('name')
 423         self.assertRaises(TypeError, f, a)
 424         self.assertRaises(TypeError, operator.itemgetter)
 425
 426         d = dict(key='val')
 427         f = operator.itemgetter('key')
 428         self.assertEqual(f(d), 'val')
 429         f = operator.itemgetter('nonkey')
 430         self.assertRaises(KeyError, f, d)
 431
 432         # example used in the docs
 433         inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
 434         getcount = operator.itemgetter(1)
 435         self.assertEqual(map(getcount, inventory), [3, 2, 5, 1])
 436         self.assertEqual(sorted(inventory, key=getcount),
 437             [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)])
 438
 439         # multiple gets
 440         data = map(str, range(20))
 441         self.assertEqual(operator.itemgetter(2,10,5)(data), ('2', '10', '5'))
 442         self.assertRaises(TypeError, operator.itemgetter(2, 'x', 5), data)
 443
 444     def test_methodcaller(self):
 445         self.assertRaises(TypeError, operator.methodcaller)
 446         class A:
 447             def foo(self, *args, **kwds):
 448                 return args[0] + args[1]
 449             def bar(self, f=42):
 450                 return f
 451         a = A()
 452         f = operator.methodcaller('foo')
 453         self.assertRaises(IndexError, f, a)
 454         f = operator.methodcaller('foo', 1, 2)
 455         self.assertEquals(f(a), 3)
 456         f = operator.methodcaller('bar')
 457         self.assertEquals(f(a), 42)
 458         self.assertRaises(TypeError, f, a, a)
 459         f = operator.methodcaller('bar', f=5)
 460         self.assertEquals(f(a), 5)
 461
 462     def test_inplace(self):
 463         class C(object):
 464             def __iadd__     (self, other): return "iadd"
 465             def __iand__     (self, other): return "iand"
 466             def __idiv__     (self, other): return "idiv"
 467             def __ifloordiv__(self, other): return "ifloordiv"
 468             def __ilshift__  (self, other): return "ilshift"
 469             def __imod__     (self, other): return "imod"
 470             def __imul__     (self, other): return "imul"
 471             def __ior__      (self, other): return "ior"
 472             def __ipow__     (self, other): return "ipow"
 473             def __irshift__  (self, other): return "irshift"
 474             def __isub__     (self, other): return "isub"
 475             def __itruediv__ (self, other): return "itruediv"
 476             def __ixor__     (self, other): return "ixor"
 477             def __getitem__(self, other): return 5  # so that C is a sequence
 478         c = C()
 479         self.assertEqual(operator.iadd     (c, 5), "iadd")
 480         self.assertEqual(operator.iand     (c, 5), "iand")
 481         self.assertEqual(operator.idiv     (c, 5), "idiv")
 482         self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv")
 483         self.assertEqual(operator.ilshift  (c, 5), "ilshift")
 484         self.assertEqual(operator.imod     (c, 5), "imod")
 485         self.assertEqual(operator.imul     (c, 5), "imul")
 486         self.assertEqual(operator.ior      (c, 5), "ior")
 487         self.assertEqual(operator.ipow     (c, 5), "ipow")
 488         self.assertEqual(operator.irshift  (c, 5), "irshift")
 489         self.assertEqual(operator.isub     (c, 5), "isub")
 490         self.assertEqual(operator.itruediv (c, 5), "itruediv")
 491         self.assertEqual(operator.ixor     (c, 5), "ixor")
 492         self.assertEqual(operator.iconcat  (c, c), "iadd")
 493         self.assertEqual(operator.irepeat  (c, 5), "imul")
 494         self.assertEqual(operator.__iadd__     (c, 5), "iadd")
 495         self.assertEqual(operator.__iand__     (c, 5), "iand")
 496         self.assertEqual(operator.__idiv__     (c, 5), "idiv")
 497         self.assertEqual(operator.__ifloordiv__(c, 5), "ifloordiv")
 498         self.assertEqual(operator.__ilshift__  (c, 5), "ilshift")
 499         self.assertEqual(operator.__imod__     (c, 5), "imod")
 500         self.assertEqual(operator.__imul__     (c, 5), "imul")
 501         self.assertEqual(operator.__ior__      (c, 5), "ior")
 502         self.assertEqual(operator.__ipow__     (c, 5), "ipow")
 503         self.assertEqual(operator.__irshift__  (c, 5), "irshift")
 504         self.assertEqual(operator.__isub__     (c, 5), "isub")
 505         self.assertEqual(operator.__itruediv__ (c, 5), "itruediv")
 506         self.assertEqual(operator.__ixor__     (c, 5), "ixor")
 507         self.assertEqual(operator.__iconcat__  (c, c), "iadd")
 508         self.assertEqual(operator.__irepeat__  (c, 5), "imul")
 509
 510 def test_main(verbose=None):
 511     import sys
 512     test_classes = (
 513         OperatorTestCase,
 514     )
 515
 516     test_support.run_unittest(*test_classes)
 517
 518     # verify reference counting
 519     if verbose and hasattr(sys, "gettotalrefcount"):
 520         import gc
 521         counts = [None] * 5
 522         for i in xrange(len(counts)):
 523             test_support.run_unittest(*test_classes)
 524             gc.collect()
 525             counts[i] = sys.gettotalrefcount()
 526         print counts
 527
 528 if __name__ == "__main__":
 529     test_main(verbose=True)