/Lib/test/test_deque.py

http://unladen-swallow.googlecode.com/ · Python · 705 lines · 582 code · 86 blank · 37 comment · 64 complexity · 9524415fd11032f7d520bbe2be28b563 MD5 · raw file

  1. from collections import deque
  2. import unittest
  3. from test import test_support, seq_tests
  4. import gc
  5. import weakref
  6. import copy
  7. import cPickle as pickle
  8. import random
  9. import os
  10. BIG = 100000
  11. def fail():
  12. raise SyntaxError
  13. yield 1
  14. class BadCmp:
  15. def __eq__(self, other):
  16. raise RuntimeError
  17. class MutateCmp:
  18. def __init__(self, deque, result):
  19. self.deque = deque
  20. self.result = result
  21. def __eq__(self, other):
  22. self.deque.clear()
  23. return self.result
  24. class TestBasic(unittest.TestCase):
  25. def test_basics(self):
  26. d = deque(xrange(-5125, -5000))
  27. d.__init__(xrange(200))
  28. for i in xrange(200, 400):
  29. d.append(i)
  30. for i in reversed(xrange(-200, 0)):
  31. d.appendleft(i)
  32. self.assertEqual(list(d), range(-200, 400))
  33. self.assertEqual(len(d), 600)
  34. left = [d.popleft() for i in xrange(250)]
  35. self.assertEqual(left, range(-200, 50))
  36. self.assertEqual(list(d), range(50, 400))
  37. right = [d.pop() for i in xrange(250)]
  38. right.reverse()
  39. self.assertEqual(right, range(150, 400))
  40. self.assertEqual(list(d), range(50, 150))
  41. def test_maxlen(self):
  42. self.assertRaises(ValueError, deque, 'abc', -1)
  43. self.assertRaises(ValueError, deque, 'abc', -2)
  44. d = deque(range(10), maxlen=3)
  45. self.assertEqual(repr(d), 'deque([7, 8, 9], maxlen=3)')
  46. self.assertEqual(list(d), range(7, 10))
  47. self.assertEqual(d, deque(range(10), 3))
  48. d.append(10)
  49. self.assertEqual(list(d), range(8, 11))
  50. d.appendleft(7)
  51. self.assertEqual(list(d), range(7, 10))
  52. d.extend([10, 11])
  53. self.assertEqual(list(d), range(9, 12))
  54. d.extendleft([8, 7])
  55. self.assertEqual(list(d), range(7, 10))
  56. d = deque(xrange(200), maxlen=10)
  57. d.append(d)
  58. test_support.unlink(test_support.TESTFN)
  59. fo = open(test_support.TESTFN, "wb")
  60. try:
  61. print >> fo, d,
  62. fo.close()
  63. fo = open(test_support.TESTFN, "rb")
  64. self.assertEqual(fo.read(), repr(d))
  65. finally:
  66. fo.close()
  67. test_support.unlink(test_support.TESTFN)
  68. d = deque(range(10), maxlen=None)
  69. self.assertEqual(repr(d), 'deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])')
  70. fo = open(test_support.TESTFN, "wb")
  71. try:
  72. print >> fo, d,
  73. fo.close()
  74. fo = open(test_support.TESTFN, "rb")
  75. self.assertEqual(fo.read(), repr(d))
  76. finally:
  77. fo.close()
  78. test_support.unlink(test_support.TESTFN)
  79. def test_comparisons(self):
  80. d = deque('xabc'); d.popleft()
  81. for e in [d, deque('abc'), deque('ab'), deque(), list(d)]:
  82. self.assertEqual(d==e, type(d)==type(e) and list(d)==list(e))
  83. self.assertEqual(d!=e, not(type(d)==type(e) and list(d)==list(e)))
  84. args = map(deque, ('', 'a', 'b', 'ab', 'ba', 'abc', 'xba', 'xabc', 'cba'))
  85. for x in args:
  86. for y in args:
  87. self.assertEqual(x == y, list(x) == list(y), (x,y))
  88. self.assertEqual(x != y, list(x) != list(y), (x,y))
  89. self.assertEqual(x < y, list(x) < list(y), (x,y))
  90. self.assertEqual(x <= y, list(x) <= list(y), (x,y))
  91. self.assertEqual(x > y, list(x) > list(y), (x,y))
  92. self.assertEqual(x >= y, list(x) >= list(y), (x,y))
  93. self.assertEqual(cmp(x,y), cmp(list(x),list(y)), (x,y))
  94. def test_extend(self):
  95. d = deque('a')
  96. self.assertRaises(TypeError, d.extend, 1)
  97. d.extend('bcd')
  98. self.assertEqual(list(d), list('abcd'))
  99. def test_extendleft(self):
  100. d = deque('a')
  101. self.assertRaises(TypeError, d.extendleft, 1)
  102. d.extendleft('bcd')
  103. self.assertEqual(list(d), list(reversed('abcd')))
  104. d = deque()
  105. d.extendleft(range(1000))
  106. self.assertEqual(list(d), list(reversed(range(1000))))
  107. self.assertRaises(SyntaxError, d.extendleft, fail())
  108. def test_getitem(self):
  109. n = 200
  110. d = deque(xrange(n))
  111. l = range(n)
  112. for i in xrange(n):
  113. d.popleft()
  114. l.pop(0)
  115. if random.random() < 0.5:
  116. d.append(i)
  117. l.append(i)
  118. for j in xrange(1-len(l), len(l)):
  119. assert d[j] == l[j]
  120. d = deque('superman')
  121. self.assertEqual(d[0], 's')
  122. self.assertEqual(d[-1], 'n')
  123. d = deque()
  124. self.assertRaises(IndexError, d.__getitem__, 0)
  125. self.assertRaises(IndexError, d.__getitem__, -1)
  126. def test_setitem(self):
  127. n = 200
  128. d = deque(xrange(n))
  129. for i in xrange(n):
  130. d[i] = 10 * i
  131. self.assertEqual(list(d), [10*i for i in xrange(n)])
  132. l = list(d)
  133. for i in xrange(1-n, 0, -1):
  134. d[i] = 7*i
  135. l[i] = 7*i
  136. self.assertEqual(list(d), l)
  137. def test_delitem(self):
  138. n = 500 # O(n**2) test, don't make this too big
  139. d = deque(xrange(n))
  140. self.assertRaises(IndexError, d.__delitem__, -n-1)
  141. self.assertRaises(IndexError, d.__delitem__, n)
  142. for i in xrange(n):
  143. self.assertEqual(len(d), n-i)
  144. j = random.randrange(-len(d), len(d))
  145. val = d[j]
  146. self.assert_(val in d)
  147. del d[j]
  148. self.assert_(val not in d)
  149. self.assertEqual(len(d), 0)
  150. def test_rotate(self):
  151. s = tuple('abcde')
  152. n = len(s)
  153. d = deque(s)
  154. d.rotate(1) # verify rot(1)
  155. self.assertEqual(''.join(d), 'eabcd')
  156. d = deque(s)
  157. d.rotate(-1) # verify rot(-1)
  158. self.assertEqual(''.join(d), 'bcdea')
  159. d.rotate() # check default to 1
  160. self.assertEqual(tuple(d), s)
  161. for i in xrange(n*3):
  162. d = deque(s)
  163. e = deque(d)
  164. d.rotate(i) # check vs. rot(1) n times
  165. for j in xrange(i):
  166. e.rotate(1)
  167. self.assertEqual(tuple(d), tuple(e))
  168. d.rotate(-i) # check that it works in reverse
  169. self.assertEqual(tuple(d), s)
  170. e.rotate(n-i) # check that it wraps forward
  171. self.assertEqual(tuple(e), s)
  172. for i in xrange(n*3):
  173. d = deque(s)
  174. e = deque(d)
  175. d.rotate(-i)
  176. for j in xrange(i):
  177. e.rotate(-1) # check vs. rot(-1) n times
  178. self.assertEqual(tuple(d), tuple(e))
  179. d.rotate(i) # check that it works in reverse
  180. self.assertEqual(tuple(d), s)
  181. e.rotate(i-n) # check that it wraps backaround
  182. self.assertEqual(tuple(e), s)
  183. d = deque(s)
  184. e = deque(s)
  185. e.rotate(BIG+17) # verify on long series of rotates
  186. dr = d.rotate
  187. for i in xrange(BIG+17):
  188. dr()
  189. self.assertEqual(tuple(d), tuple(e))
  190. self.assertRaises(TypeError, d.rotate, 'x') # Wrong arg type
  191. self.assertRaises(TypeError, d.rotate, 1, 10) # Too many args
  192. d = deque()
  193. d.rotate() # rotate an empty deque
  194. self.assertEqual(d, deque())
  195. def test_len(self):
  196. d = deque('ab')
  197. self.assertEqual(len(d), 2)
  198. d.popleft()
  199. self.assertEqual(len(d), 1)
  200. d.pop()
  201. self.assertEqual(len(d), 0)
  202. self.assertRaises(IndexError, d.pop)
  203. self.assertEqual(len(d), 0)
  204. d.append('c')
  205. self.assertEqual(len(d), 1)
  206. d.appendleft('d')
  207. self.assertEqual(len(d), 2)
  208. d.clear()
  209. self.assertEqual(len(d), 0)
  210. def test_underflow(self):
  211. d = deque()
  212. self.assertRaises(IndexError, d.pop)
  213. self.assertRaises(IndexError, d.popleft)
  214. def test_clear(self):
  215. d = deque(xrange(100))
  216. self.assertEqual(len(d), 100)
  217. d.clear()
  218. self.assertEqual(len(d), 0)
  219. self.assertEqual(list(d), [])
  220. d.clear() # clear an emtpy deque
  221. self.assertEqual(list(d), [])
  222. def test_remove(self):
  223. d = deque('abcdefghcij')
  224. d.remove('c')
  225. self.assertEqual(d, deque('abdefghcij'))
  226. d.remove('c')
  227. self.assertEqual(d, deque('abdefghij'))
  228. self.assertRaises(ValueError, d.remove, 'c')
  229. self.assertEqual(d, deque('abdefghij'))
  230. # Handle comparison errors
  231. d = deque(['a', 'b', BadCmp(), 'c'])
  232. e = deque(d)
  233. self.assertRaises(RuntimeError, d.remove, 'c')
  234. for x, y in zip(d, e):
  235. # verify that original order and values are retained.
  236. self.assert_(x is y)
  237. # Handle evil mutator
  238. for match in (True, False):
  239. d = deque(['ab'])
  240. d.extend([MutateCmp(d, match), 'c'])
  241. self.assertRaises(IndexError, d.remove, 'c')
  242. self.assertEqual(d, deque())
  243. def test_repr(self):
  244. d = deque(xrange(200))
  245. e = eval(repr(d))
  246. self.assertEqual(list(d), list(e))
  247. d.append(d)
  248. self.assert_('...' in repr(d))
  249. def test_print(self):
  250. d = deque(xrange(200))
  251. d.append(d)
  252. test_support.unlink(test_support.TESTFN)
  253. fo = open(test_support.TESTFN, "wb")
  254. try:
  255. print >> fo, d,
  256. fo.close()
  257. fo = open(test_support.TESTFN, "rb")
  258. self.assertEqual(fo.read(), repr(d))
  259. finally:
  260. fo.close()
  261. test_support.unlink(test_support.TESTFN)
  262. def test_init(self):
  263. self.assertRaises(TypeError, deque, 'abc', 2, 3);
  264. self.assertRaises(TypeError, deque, 1);
  265. def test_hash(self):
  266. self.assertRaises(TypeError, hash, deque('abc'))
  267. def test_long_steadystate_queue_popleft(self):
  268. for size in (0, 1, 2, 100, 1000):
  269. d = deque(xrange(size))
  270. append, pop = d.append, d.popleft
  271. for i in xrange(size, BIG):
  272. append(i)
  273. x = pop()
  274. if x != i - size:
  275. self.assertEqual(x, i-size)
  276. self.assertEqual(list(d), range(BIG-size, BIG))
  277. def test_long_steadystate_queue_popright(self):
  278. for size in (0, 1, 2, 100, 1000):
  279. d = deque(reversed(xrange(size)))
  280. append, pop = d.appendleft, d.pop
  281. for i in xrange(size, BIG):
  282. append(i)
  283. x = pop()
  284. if x != i - size:
  285. self.assertEqual(x, i-size)
  286. self.assertEqual(list(reversed(list(d))), range(BIG-size, BIG))
  287. def test_big_queue_popleft(self):
  288. pass
  289. d = deque()
  290. append, pop = d.append, d.popleft
  291. for i in xrange(BIG):
  292. append(i)
  293. for i in xrange(BIG):
  294. x = pop()
  295. if x != i:
  296. self.assertEqual(x, i)
  297. def test_big_queue_popright(self):
  298. d = deque()
  299. append, pop = d.appendleft, d.pop
  300. for i in xrange(BIG):
  301. append(i)
  302. for i in xrange(BIG):
  303. x = pop()
  304. if x != i:
  305. self.assertEqual(x, i)
  306. def test_big_stack_right(self):
  307. d = deque()
  308. append, pop = d.append, d.pop
  309. for i in xrange(BIG):
  310. append(i)
  311. for i in reversed(xrange(BIG)):
  312. x = pop()
  313. if x != i:
  314. self.assertEqual(x, i)
  315. self.assertEqual(len(d), 0)
  316. def test_big_stack_left(self):
  317. d = deque()
  318. append, pop = d.appendleft, d.popleft
  319. for i in xrange(BIG):
  320. append(i)
  321. for i in reversed(xrange(BIG)):
  322. x = pop()
  323. if x != i:
  324. self.assertEqual(x, i)
  325. self.assertEqual(len(d), 0)
  326. def test_roundtrip_iter_init(self):
  327. d = deque(xrange(200))
  328. e = deque(d)
  329. self.assertNotEqual(id(d), id(e))
  330. self.assertEqual(list(d), list(e))
  331. def test_pickle(self):
  332. d = deque(xrange(200))
  333. for i in range(pickle.HIGHEST_PROTOCOL + 1):
  334. s = pickle.dumps(d, i)
  335. e = pickle.loads(s)
  336. self.assertNotEqual(id(d), id(e))
  337. self.assertEqual(list(d), list(e))
  338. ## def test_pickle_recursive(self):
  339. ## d = deque('abc')
  340. ## d.append(d)
  341. ## for i in range(pickle.HIGHEST_PROTOCOL + 1):
  342. ## e = pickle.loads(pickle.dumps(d, i))
  343. ## self.assertNotEqual(id(d), id(e))
  344. ## self.assertEqual(id(e), id(e[-1]))
  345. def test_deepcopy(self):
  346. mut = [10]
  347. d = deque([mut])
  348. e = copy.deepcopy(d)
  349. self.assertEqual(list(d), list(e))
  350. mut[0] = 11
  351. self.assertNotEqual(id(d), id(e))
  352. self.assertNotEqual(list(d), list(e))
  353. def test_copy(self):
  354. mut = [10]
  355. d = deque([mut])
  356. e = copy.copy(d)
  357. self.assertEqual(list(d), list(e))
  358. mut[0] = 11
  359. self.assertNotEqual(id(d), id(e))
  360. self.assertEqual(list(d), list(e))
  361. def test_reversed(self):
  362. for s in ('abcd', xrange(2000)):
  363. self.assertEqual(list(reversed(deque(s))), list(reversed(s)))
  364. def test_gc_doesnt_blowup(self):
  365. import gc
  366. # This used to assert-fail in deque_traverse() under a debug
  367. # build, or run wild with a NULL pointer in a release build.
  368. d = deque()
  369. for i in xrange(100):
  370. d.append(1)
  371. gc.collect()
  372. def test_container_iterator(self):
  373. # Bug #3680: tp_traverse was not implemented for deque iterator objects
  374. class C(object):
  375. pass
  376. for i in range(2):
  377. obj = C()
  378. ref = weakref.ref(obj)
  379. if i == 0:
  380. container = deque([obj, 1])
  381. else:
  382. container = reversed(deque([obj, 1]))
  383. obj.x = iter(container)
  384. del obj, container
  385. gc.collect()
  386. self.assert_(ref() is None, "Cycle was not collected")
  387. class TestVariousIteratorArgs(unittest.TestCase):
  388. def test_constructor(self):
  389. for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  390. for g in (seq_tests.Sequence, seq_tests.IterFunc,
  391. seq_tests.IterGen, seq_tests.IterFuncStop,
  392. seq_tests.itermulti, seq_tests.iterfunc):
  393. self.assertEqual(list(deque(g(s))), list(g(s)))
  394. self.assertRaises(TypeError, deque, seq_tests.IterNextOnly(s))
  395. self.assertRaises(TypeError, deque, seq_tests.IterNoNext(s))
  396. self.assertRaises(ZeroDivisionError, deque, seq_tests.IterGenExc(s))
  397. def test_iter_with_altered_data(self):
  398. d = deque('abcdefg')
  399. it = iter(d)
  400. d.pop()
  401. self.assertRaises(RuntimeError, it.next)
  402. def test_runtime_error_on_empty_deque(self):
  403. d = deque()
  404. it = iter(d)
  405. d.append(10)
  406. self.assertRaises(RuntimeError, it.next)
  407. class Deque(deque):
  408. pass
  409. class DequeWithBadIter(deque):
  410. def __iter__(self):
  411. raise TypeError
  412. class TestSubclass(unittest.TestCase):
  413. def test_basics(self):
  414. d = Deque(xrange(25))
  415. d.__init__(xrange(200))
  416. for i in xrange(200, 400):
  417. d.append(i)
  418. for i in reversed(xrange(-200, 0)):
  419. d.appendleft(i)
  420. self.assertEqual(list(d), range(-200, 400))
  421. self.assertEqual(len(d), 600)
  422. left = [d.popleft() for i in xrange(250)]
  423. self.assertEqual(left, range(-200, 50))
  424. self.assertEqual(list(d), range(50, 400))
  425. right = [d.pop() for i in xrange(250)]
  426. right.reverse()
  427. self.assertEqual(right, range(150, 400))
  428. self.assertEqual(list(d), range(50, 150))
  429. d.clear()
  430. self.assertEqual(len(d), 0)
  431. def test_copy_pickle(self):
  432. d = Deque('abc')
  433. e = d.__copy__()
  434. self.assertEqual(type(d), type(e))
  435. self.assertEqual(list(d), list(e))
  436. e = Deque(d)
  437. self.assertEqual(type(d), type(e))
  438. self.assertEqual(list(d), list(e))
  439. s = pickle.dumps(d)
  440. e = pickle.loads(s)
  441. self.assertNotEqual(id(d), id(e))
  442. self.assertEqual(type(d), type(e))
  443. self.assertEqual(list(d), list(e))
  444. d = Deque('abcde', maxlen=4)
  445. e = d.__copy__()
  446. self.assertEqual(type(d), type(e))
  447. self.assertEqual(list(d), list(e))
  448. e = Deque(d)
  449. self.assertEqual(type(d), type(e))
  450. self.assertEqual(list(d), list(e))
  451. s = pickle.dumps(d)
  452. e = pickle.loads(s)
  453. self.assertNotEqual(id(d), id(e))
  454. self.assertEqual(type(d), type(e))
  455. self.assertEqual(list(d), list(e))
  456. ## def test_pickle(self):
  457. ## d = Deque('abc')
  458. ## d.append(d)
  459. ##
  460. ## e = pickle.loads(pickle.dumps(d))
  461. ## self.assertNotEqual(id(d), id(e))
  462. ## self.assertEqual(type(d), type(e))
  463. ## dd = d.pop()
  464. ## ee = e.pop()
  465. ## self.assertEqual(id(e), id(ee))
  466. ## self.assertEqual(d, e)
  467. ##
  468. ## d.x = d
  469. ## e = pickle.loads(pickle.dumps(d))
  470. ## self.assertEqual(id(e), id(e.x))
  471. ##
  472. ## d = DequeWithBadIter('abc')
  473. ## self.assertRaises(TypeError, pickle.dumps, d)
  474. def test_weakref(self):
  475. d = deque('gallahad')
  476. p = weakref.proxy(d)
  477. self.assertEqual(str(p), str(d))
  478. d = None
  479. self.assertRaises(ReferenceError, str, p)
  480. def test_strange_subclass(self):
  481. class X(deque):
  482. def __iter__(self):
  483. return iter([])
  484. d1 = X([1,2,3])
  485. d2 = X([4,5,6])
  486. d1 == d2 # not clear if this is supposed to be True or False,
  487. # but it used to give a SystemError
  488. class SubclassWithKwargs(deque):
  489. def __init__(self, newarg=1):
  490. deque.__init__(self)
  491. class TestSubclassWithKwargs(unittest.TestCase):
  492. def test_subclass_with_kwargs(self):
  493. # SF bug #1486663 -- this used to erroneously raise a TypeError
  494. SubclassWithKwargs(newarg=1)
  495. #==============================================================================
  496. libreftest = """
  497. Example from the Library Reference: Doc/lib/libcollections.tex
  498. >>> from collections import deque
  499. >>> d = deque('ghi') # make a new deque with three items
  500. >>> for elem in d: # iterate over the deque's elements
  501. ... print elem.upper()
  502. G
  503. H
  504. I
  505. >>> d.append('j') # add a new entry to the right side
  506. >>> d.appendleft('f') # add a new entry to the left side
  507. >>> d # show the representation of the deque
  508. deque(['f', 'g', 'h', 'i', 'j'])
  509. >>> d.pop() # return and remove the rightmost item
  510. 'j'
  511. >>> d.popleft() # return and remove the leftmost item
  512. 'f'
  513. >>> list(d) # list the contents of the deque
  514. ['g', 'h', 'i']
  515. >>> d[0] # peek at leftmost item
  516. 'g'
  517. >>> d[-1] # peek at rightmost item
  518. 'i'
  519. >>> list(reversed(d)) # list the contents of a deque in reverse
  520. ['i', 'h', 'g']
  521. >>> 'h' in d # search the deque
  522. True
  523. >>> d.extend('jkl') # add multiple elements at once
  524. >>> d
  525. deque(['g', 'h', 'i', 'j', 'k', 'l'])
  526. >>> d.rotate(1) # right rotation
  527. >>> d
  528. deque(['l', 'g', 'h', 'i', 'j', 'k'])
  529. >>> d.rotate(-1) # left rotation
  530. >>> d
  531. deque(['g', 'h', 'i', 'j', 'k', 'l'])
  532. >>> deque(reversed(d)) # make a new deque in reverse order
  533. deque(['l', 'k', 'j', 'i', 'h', 'g'])
  534. >>> d.clear() # empty the deque
  535. >>> d.pop() # cannot pop from an empty deque
  536. Traceback (most recent call last):
  537. File "<pyshell#6>", line 1, in -toplevel-
  538. d.pop()
  539. IndexError: pop from an empty deque
  540. >>> d.extendleft('abc') # extendleft() reverses the input order
  541. >>> d
  542. deque(['c', 'b', 'a'])
  543. >>> def delete_nth(d, n):
  544. ... d.rotate(-n)
  545. ... d.popleft()
  546. ... d.rotate(n)
  547. ...
  548. >>> d = deque('abcdef')
  549. >>> delete_nth(d, 2) # remove the entry at d[2]
  550. >>> d
  551. deque(['a', 'b', 'd', 'e', 'f'])
  552. >>> def roundrobin(*iterables):
  553. ... pending = deque(iter(i) for i in iterables)
  554. ... while pending:
  555. ... task = pending.popleft()
  556. ... try:
  557. ... yield task.next()
  558. ... except StopIteration:
  559. ... continue
  560. ... pending.append(task)
  561. ...
  562. >>> for value in roundrobin('abc', 'd', 'efgh'):
  563. ... print value
  564. ...
  565. a
  566. d
  567. e
  568. b
  569. f
  570. c
  571. g
  572. h
  573. >>> def maketree(iterable):
  574. ... d = deque(iterable)
  575. ... while len(d) > 1:
  576. ... pair = [d.popleft(), d.popleft()]
  577. ... d.append(pair)
  578. ... return list(d)
  579. ...
  580. >>> print maketree('abcdefgh')
  581. [[[['a', 'b'], ['c', 'd']], [['e', 'f'], ['g', 'h']]]]
  582. """
  583. #==============================================================================
  584. __test__ = {'libreftest' : libreftest}
  585. def test_main(verbose=None):
  586. import sys
  587. test_classes = (
  588. TestBasic,
  589. TestVariousIteratorArgs,
  590. TestSubclass,
  591. TestSubclassWithKwargs,
  592. )
  593. test_support.run_unittest(*test_classes)
  594. # verify reference counting
  595. if verbose and hasattr(sys, "gettotalrefcount"):
  596. import gc
  597. counts = [None] * 5
  598. for i in xrange(len(counts)):
  599. test_support.run_unittest(*test_classes)
  600. gc.collect()
  601. counts[i] = sys.gettotalrefcount()
  602. print counts
  603. # doctests
  604. from test import test_deque
  605. test_support.run_doctest(test_deque, verbose)
  606. if __name__ == "__main__":
  607. test_main(verbose=True)