/Lib/test/test_operator.py

http://unladen-swallow.googlecode.com/ · Python · 529 lines · 462 code · 62 blank · 5 comment · 4 complexity · 8e007ef3df61f31e9aa2148d4c0a5bf9 MD5 · raw file

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