/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
- from collections import deque
- import unittest
- from test import test_support, seq_tests
- import gc
- import weakref
- import copy
- import cPickle as pickle
- import random
- import os
- BIG = 100000
- def fail():
- raise SyntaxError
- yield 1
- class BadCmp:
- def __eq__(self, other):
- raise RuntimeError
- class MutateCmp:
- def __init__(self, deque, result):
- self.deque = deque
- self.result = result
- def __eq__(self, other):
- self.deque.clear()
- return self.result
- class TestBasic(unittest.TestCase):
- def test_basics(self):
- d = deque(xrange(-5125, -5000))
- d.__init__(xrange(200))
- for i in xrange(200, 400):
- d.append(i)
- for i in reversed(xrange(-200, 0)):
- d.appendleft(i)
- self.assertEqual(list(d), range(-200, 400))
- self.assertEqual(len(d), 600)
- left = [d.popleft() for i in xrange(250)]
- self.assertEqual(left, range(-200, 50))
- self.assertEqual(list(d), range(50, 400))
- right = [d.pop() for i in xrange(250)]
- right.reverse()
- self.assertEqual(right, range(150, 400))
- self.assertEqual(list(d), range(50, 150))
- def test_maxlen(self):
- self.assertRaises(ValueError, deque, 'abc', -1)
- self.assertRaises(ValueError, deque, 'abc', -2)
- d = deque(range(10), maxlen=3)
- self.assertEqual(repr(d), 'deque([7, 8, 9], maxlen=3)')
- self.assertEqual(list(d), range(7, 10))
- self.assertEqual(d, deque(range(10), 3))
- d.append(10)
- self.assertEqual(list(d), range(8, 11))
- d.appendleft(7)
- self.assertEqual(list(d), range(7, 10))
- d.extend([10, 11])
- self.assertEqual(list(d), range(9, 12))
- d.extendleft([8, 7])
- self.assertEqual(list(d), range(7, 10))
- d = deque(xrange(200), maxlen=10)
- d.append(d)
- test_support.unlink(test_support.TESTFN)
- fo = open(test_support.TESTFN, "wb")
- try:
- print >> fo, d,
- fo.close()
- fo = open(test_support.TESTFN, "rb")
- self.assertEqual(fo.read(), repr(d))
- finally:
- fo.close()
- test_support.unlink(test_support.TESTFN)
- d = deque(range(10), maxlen=None)
- self.assertEqual(repr(d), 'deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])')
- fo = open(test_support.TESTFN, "wb")
- try:
- print >> fo, d,
- fo.close()
- fo = open(test_support.TESTFN, "rb")
- self.assertEqual(fo.read(), repr(d))
- finally:
- fo.close()
- test_support.unlink(test_support.TESTFN)
- def test_comparisons(self):
- d = deque('xabc'); d.popleft()
- for e in [d, deque('abc'), deque('ab'), deque(), list(d)]:
- self.assertEqual(d==e, type(d)==type(e) and list(d)==list(e))
- self.assertEqual(d!=e, not(type(d)==type(e) and list(d)==list(e)))
- args = map(deque, ('', 'a', 'b', 'ab', 'ba', 'abc', 'xba', 'xabc', 'cba'))
- for x in args:
- for y in args:
- self.assertEqual(x == y, list(x) == list(y), (x,y))
- self.assertEqual(x != y, list(x) != list(y), (x,y))
- self.assertEqual(x < y, list(x) < list(y), (x,y))
- self.assertEqual(x <= y, list(x) <= list(y), (x,y))
- self.assertEqual(x > y, list(x) > list(y), (x,y))
- self.assertEqual(x >= y, list(x) >= list(y), (x,y))
- self.assertEqual(cmp(x,y), cmp(list(x),list(y)), (x,y))
- def test_extend(self):
- d = deque('a')
- self.assertRaises(TypeError, d.extend, 1)
- d.extend('bcd')
- self.assertEqual(list(d), list('abcd'))
- def test_extendleft(self):
- d = deque('a')
- self.assertRaises(TypeError, d.extendleft, 1)
- d.extendleft('bcd')
- self.assertEqual(list(d), list(reversed('abcd')))
- d = deque()
- d.extendleft(range(1000))
- self.assertEqual(list(d), list(reversed(range(1000))))
- self.assertRaises(SyntaxError, d.extendleft, fail())
- def test_getitem(self):
- n = 200
- d = deque(xrange(n))
- l = range(n)
- for i in xrange(n):
- d.popleft()
- l.pop(0)
- if random.random() < 0.5:
- d.append(i)
- l.append(i)
- for j in xrange(1-len(l), len(l)):
- assert d[j] == l[j]
- d = deque('superman')
- self.assertEqual(d[0], 's')
- self.assertEqual(d[-1], 'n')
- d = deque()
- self.assertRaises(IndexError, d.__getitem__, 0)
- self.assertRaises(IndexError, d.__getitem__, -1)
- def test_setitem(self):
- n = 200
- d = deque(xrange(n))
- for i in xrange(n):
- d[i] = 10 * i
- self.assertEqual(list(d), [10*i for i in xrange(n)])
- l = list(d)
- for i in xrange(1-n, 0, -1):
- d[i] = 7*i
- l[i] = 7*i
- self.assertEqual(list(d), l)
- def test_delitem(self):
- n = 500 # O(n**2) test, don't make this too big
- d = deque(xrange(n))
- self.assertRaises(IndexError, d.__delitem__, -n-1)
- self.assertRaises(IndexError, d.__delitem__, n)
- for i in xrange(n):
- self.assertEqual(len(d), n-i)
- j = random.randrange(-len(d), len(d))
- val = d[j]
- self.assert_(val in d)
- del d[j]
- self.assert_(val not in d)
- self.assertEqual(len(d), 0)
- def test_rotate(self):
- s = tuple('abcde')
- n = len(s)
- d = deque(s)
- d.rotate(1) # verify rot(1)
- self.assertEqual(''.join(d), 'eabcd')
- d = deque(s)
- d.rotate(-1) # verify rot(-1)
- self.assertEqual(''.join(d), 'bcdea')
- d.rotate() # check default to 1
- self.assertEqual(tuple(d), s)
- for i in xrange(n*3):
- d = deque(s)
- e = deque(d)
- d.rotate(i) # check vs. rot(1) n times
- for j in xrange(i):
- e.rotate(1)
- self.assertEqual(tuple(d), tuple(e))
- d.rotate(-i) # check that it works in reverse
- self.assertEqual(tuple(d), s)
- e.rotate(n-i) # check that it wraps forward
- self.assertEqual(tuple(e), s)
- for i in xrange(n*3):
- d = deque(s)
- e = deque(d)
- d.rotate(-i)
- for j in xrange(i):
- e.rotate(-1) # check vs. rot(-1) n times
- self.assertEqual(tuple(d), tuple(e))
- d.rotate(i) # check that it works in reverse
- self.assertEqual(tuple(d), s)
- e.rotate(i-n) # check that it wraps backaround
- self.assertEqual(tuple(e), s)
- d = deque(s)
- e = deque(s)
- e.rotate(BIG+17) # verify on long series of rotates
- dr = d.rotate
- for i in xrange(BIG+17):
- dr()
- self.assertEqual(tuple(d), tuple(e))
- self.assertRaises(TypeError, d.rotate, 'x') # Wrong arg type
- self.assertRaises(TypeError, d.rotate, 1, 10) # Too many args
- d = deque()
- d.rotate() # rotate an empty deque
- self.assertEqual(d, deque())
- def test_len(self):
- d = deque('ab')
- self.assertEqual(len(d), 2)
- d.popleft()
- self.assertEqual(len(d), 1)
- d.pop()
- self.assertEqual(len(d), 0)
- self.assertRaises(IndexError, d.pop)
- self.assertEqual(len(d), 0)
- d.append('c')
- self.assertEqual(len(d), 1)
- d.appendleft('d')
- self.assertEqual(len(d), 2)
- d.clear()
- self.assertEqual(len(d), 0)
- def test_underflow(self):
- d = deque()
- self.assertRaises(IndexError, d.pop)
- self.assertRaises(IndexError, d.popleft)
- def test_clear(self):
- d = deque(xrange(100))
- self.assertEqual(len(d), 100)
- d.clear()
- self.assertEqual(len(d), 0)
- self.assertEqual(list(d), [])
- d.clear() # clear an emtpy deque
- self.assertEqual(list(d), [])
- def test_remove(self):
- d = deque('abcdefghcij')
- d.remove('c')
- self.assertEqual(d, deque('abdefghcij'))
- d.remove('c')
- self.assertEqual(d, deque('abdefghij'))
- self.assertRaises(ValueError, d.remove, 'c')
- self.assertEqual(d, deque('abdefghij'))
- # Handle comparison errors
- d = deque(['a', 'b', BadCmp(), 'c'])
- e = deque(d)
- self.assertRaises(RuntimeError, d.remove, 'c')
- for x, y in zip(d, e):
- # verify that original order and values are retained.
- self.assert_(x is y)
- # Handle evil mutator
- for match in (True, False):
- d = deque(['ab'])
- d.extend([MutateCmp(d, match), 'c'])
- self.assertRaises(IndexError, d.remove, 'c')
- self.assertEqual(d, deque())
- def test_repr(self):
- d = deque(xrange(200))
- e = eval(repr(d))
- self.assertEqual(list(d), list(e))
- d.append(d)
- self.assert_('...' in repr(d))
- def test_print(self):
- d = deque(xrange(200))
- d.append(d)
- test_support.unlink(test_support.TESTFN)
- fo = open(test_support.TESTFN, "wb")
- try:
- print >> fo, d,
- fo.close()
- fo = open(test_support.TESTFN, "rb")
- self.assertEqual(fo.read(), repr(d))
- finally:
- fo.close()
- test_support.unlink(test_support.TESTFN)
- def test_init(self):
- self.assertRaises(TypeError, deque, 'abc', 2, 3);
- self.assertRaises(TypeError, deque, 1);
- def test_hash(self):
- self.assertRaises(TypeError, hash, deque('abc'))
- def test_long_steadystate_queue_popleft(self):
- for size in (0, 1, 2, 100, 1000):
- d = deque(xrange(size))
- append, pop = d.append, d.popleft
- for i in xrange(size, BIG):
- append(i)
- x = pop()
- if x != i - size:
- self.assertEqual(x, i-size)
- self.assertEqual(list(d), range(BIG-size, BIG))
- def test_long_steadystate_queue_popright(self):
- for size in (0, 1, 2, 100, 1000):
- d = deque(reversed(xrange(size)))
- append, pop = d.appendleft, d.pop
- for i in xrange(size, BIG):
- append(i)
- x = pop()
- if x != i - size:
- self.assertEqual(x, i-size)
- self.assertEqual(list(reversed(list(d))), range(BIG-size, BIG))
- def test_big_queue_popleft(self):
- pass
- d = deque()
- append, pop = d.append, d.popleft
- for i in xrange(BIG):
- append(i)
- for i in xrange(BIG):
- x = pop()
- if x != i:
- self.assertEqual(x, i)
- def test_big_queue_popright(self):
- d = deque()
- append, pop = d.appendleft, d.pop
- for i in xrange(BIG):
- append(i)
- for i in xrange(BIG):
- x = pop()
- if x != i:
- self.assertEqual(x, i)
- def test_big_stack_right(self):
- d = deque()
- append, pop = d.append, d.pop
- for i in xrange(BIG):
- append(i)
- for i in reversed(xrange(BIG)):
- x = pop()
- if x != i:
- self.assertEqual(x, i)
- self.assertEqual(len(d), 0)
- def test_big_stack_left(self):
- d = deque()
- append, pop = d.appendleft, d.popleft
- for i in xrange(BIG):
- append(i)
- for i in reversed(xrange(BIG)):
- x = pop()
- if x != i:
- self.assertEqual(x, i)
- self.assertEqual(len(d), 0)
- def test_roundtrip_iter_init(self):
- d = deque(xrange(200))
- e = deque(d)
- self.assertNotEqual(id(d), id(e))
- self.assertEqual(list(d), list(e))
- def test_pickle(self):
- d = deque(xrange(200))
- for i in range(pickle.HIGHEST_PROTOCOL + 1):
- s = pickle.dumps(d, i)
- e = pickle.loads(s)
- self.assertNotEqual(id(d), id(e))
- self.assertEqual(list(d), list(e))
- ## def test_pickle_recursive(self):
- ## d = deque('abc')
- ## d.append(d)
- ## for i in range(pickle.HIGHEST_PROTOCOL + 1):
- ## e = pickle.loads(pickle.dumps(d, i))
- ## self.assertNotEqual(id(d), id(e))
- ## self.assertEqual(id(e), id(e[-1]))
- def test_deepcopy(self):
- mut = [10]
- d = deque([mut])
- e = copy.deepcopy(d)
- self.assertEqual(list(d), list(e))
- mut[0] = 11
- self.assertNotEqual(id(d), id(e))
- self.assertNotEqual(list(d), list(e))
- def test_copy(self):
- mut = [10]
- d = deque([mut])
- e = copy.copy(d)
- self.assertEqual(list(d), list(e))
- mut[0] = 11
- self.assertNotEqual(id(d), id(e))
- self.assertEqual(list(d), list(e))
- def test_reversed(self):
- for s in ('abcd', xrange(2000)):
- self.assertEqual(list(reversed(deque(s))), list(reversed(s)))
- def test_gc_doesnt_blowup(self):
- import gc
- # This used to assert-fail in deque_traverse() under a debug
- # build, or run wild with a NULL pointer in a release build.
- d = deque()
- for i in xrange(100):
- d.append(1)
- gc.collect()
- def test_container_iterator(self):
- # Bug #3680: tp_traverse was not implemented for deque iterator objects
- class C(object):
- pass
- for i in range(2):
- obj = C()
- ref = weakref.ref(obj)
- if i == 0:
- container = deque([obj, 1])
- else:
- container = reversed(deque([obj, 1]))
- obj.x = iter(container)
- del obj, container
- gc.collect()
- self.assert_(ref() is None, "Cycle was not collected")
- class TestVariousIteratorArgs(unittest.TestCase):
- def test_constructor(self):
- for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
- for g in (seq_tests.Sequence, seq_tests.IterFunc,
- seq_tests.IterGen, seq_tests.IterFuncStop,
- seq_tests.itermulti, seq_tests.iterfunc):
- self.assertEqual(list(deque(g(s))), list(g(s)))
- self.assertRaises(TypeError, deque, seq_tests.IterNextOnly(s))
- self.assertRaises(TypeError, deque, seq_tests.IterNoNext(s))
- self.assertRaises(ZeroDivisionError, deque, seq_tests.IterGenExc(s))
- def test_iter_with_altered_data(self):
- d = deque('abcdefg')
- it = iter(d)
- d.pop()
- self.assertRaises(RuntimeError, it.next)
- def test_runtime_error_on_empty_deque(self):
- d = deque()
- it = iter(d)
- d.append(10)
- self.assertRaises(RuntimeError, it.next)
- class Deque(deque):
- pass
- class DequeWithBadIter(deque):
- def __iter__(self):
- raise TypeError
- class TestSubclass(unittest.TestCase):
- def test_basics(self):
- d = Deque(xrange(25))
- d.__init__(xrange(200))
- for i in xrange(200, 400):
- d.append(i)
- for i in reversed(xrange(-200, 0)):
- d.appendleft(i)
- self.assertEqual(list(d), range(-200, 400))
- self.assertEqual(len(d), 600)
- left = [d.popleft() for i in xrange(250)]
- self.assertEqual(left, range(-200, 50))
- self.assertEqual(list(d), range(50, 400))
- right = [d.pop() for i in xrange(250)]
- right.reverse()
- self.assertEqual(right, range(150, 400))
- self.assertEqual(list(d), range(50, 150))
- d.clear()
- self.assertEqual(len(d), 0)
- def test_copy_pickle(self):
- d = Deque('abc')
- e = d.__copy__()
- self.assertEqual(type(d), type(e))
- self.assertEqual(list(d), list(e))
- e = Deque(d)
- self.assertEqual(type(d), type(e))
- self.assertEqual(list(d), list(e))
- s = pickle.dumps(d)
- e = pickle.loads(s)
- self.assertNotEqual(id(d), id(e))
- self.assertEqual(type(d), type(e))
- self.assertEqual(list(d), list(e))
- d = Deque('abcde', maxlen=4)
- e = d.__copy__()
- self.assertEqual(type(d), type(e))
- self.assertEqual(list(d), list(e))
- e = Deque(d)
- self.assertEqual(type(d), type(e))
- self.assertEqual(list(d), list(e))
- s = pickle.dumps(d)
- e = pickle.loads(s)
- self.assertNotEqual(id(d), id(e))
- self.assertEqual(type(d), type(e))
- self.assertEqual(list(d), list(e))
- ## def test_pickle(self):
- ## d = Deque('abc')
- ## d.append(d)
- ##
- ## e = pickle.loads(pickle.dumps(d))
- ## self.assertNotEqual(id(d), id(e))
- ## self.assertEqual(type(d), type(e))
- ## dd = d.pop()
- ## ee = e.pop()
- ## self.assertEqual(id(e), id(ee))
- ## self.assertEqual(d, e)
- ##
- ## d.x = d
- ## e = pickle.loads(pickle.dumps(d))
- ## self.assertEqual(id(e), id(e.x))
- ##
- ## d = DequeWithBadIter('abc')
- ## self.assertRaises(TypeError, pickle.dumps, d)
- def test_weakref(self):
- d = deque('gallahad')
- p = weakref.proxy(d)
- self.assertEqual(str(p), str(d))
- d = None
- self.assertRaises(ReferenceError, str, p)
- def test_strange_subclass(self):
- class X(deque):
- def __iter__(self):
- return iter([])
- d1 = X([1,2,3])
- d2 = X([4,5,6])
- d1 == d2 # not clear if this is supposed to be True or False,
- # but it used to give a SystemError
- class SubclassWithKwargs(deque):
- def __init__(self, newarg=1):
- deque.__init__(self)
- class TestSubclassWithKwargs(unittest.TestCase):
- def test_subclass_with_kwargs(self):
- # SF bug #1486663 -- this used to erroneously raise a TypeError
- SubclassWithKwargs(newarg=1)
- #==============================================================================
- libreftest = """
- Example from the Library Reference: Doc/lib/libcollections.tex
- >>> from collections import deque
- >>> d = deque('ghi') # make a new deque with three items
- >>> for elem in d: # iterate over the deque's elements
- ... print elem.upper()
- G
- H
- I
- >>> d.append('j') # add a new entry to the right side
- >>> d.appendleft('f') # add a new entry to the left side
- >>> d # show the representation of the deque
- deque(['f', 'g', 'h', 'i', 'j'])
- >>> d.pop() # return and remove the rightmost item
- 'j'
- >>> d.popleft() # return and remove the leftmost item
- 'f'
- >>> list(d) # list the contents of the deque
- ['g', 'h', 'i']
- >>> d[0] # peek at leftmost item
- 'g'
- >>> d[-1] # peek at rightmost item
- 'i'
- >>> list(reversed(d)) # list the contents of a deque in reverse
- ['i', 'h', 'g']
- >>> 'h' in d # search the deque
- True
- >>> d.extend('jkl') # add multiple elements at once
- >>> d
- deque(['g', 'h', 'i', 'j', 'k', 'l'])
- >>> d.rotate(1) # right rotation
- >>> d
- deque(['l', 'g', 'h', 'i', 'j', 'k'])
- >>> d.rotate(-1) # left rotation
- >>> d
- deque(['g', 'h', 'i', 'j', 'k', 'l'])
- >>> deque(reversed(d)) # make a new deque in reverse order
- deque(['l', 'k', 'j', 'i', 'h', 'g'])
- >>> d.clear() # empty the deque
- >>> d.pop() # cannot pop from an empty deque
- Traceback (most recent call last):
- File "<pyshell#6>", line 1, in -toplevel-
- d.pop()
- IndexError: pop from an empty deque
- >>> d.extendleft('abc') # extendleft() reverses the input order
- >>> d
- deque(['c', 'b', 'a'])
- >>> def delete_nth(d, n):
- ... d.rotate(-n)
- ... d.popleft()
- ... d.rotate(n)
- ...
- >>> d = deque('abcdef')
- >>> delete_nth(d, 2) # remove the entry at d[2]
- >>> d
- deque(['a', 'b', 'd', 'e', 'f'])
- >>> def roundrobin(*iterables):
- ... pending = deque(iter(i) for i in iterables)
- ... while pending:
- ... task = pending.popleft()
- ... try:
- ... yield task.next()
- ... except StopIteration:
- ... continue
- ... pending.append(task)
- ...
- >>> for value in roundrobin('abc', 'd', 'efgh'):
- ... print value
- ...
- a
- d
- e
- b
- f
- c
- g
- h
- >>> def maketree(iterable):
- ... d = deque(iterable)
- ... while len(d) > 1:
- ... pair = [d.popleft(), d.popleft()]
- ... d.append(pair)
- ... return list(d)
- ...
- >>> print maketree('abcdefgh')
- [[[['a', 'b'], ['c', 'd']], [['e', 'f'], ['g', 'h']]]]
- """
- #==============================================================================
- __test__ = {'libreftest' : libreftest}
- def test_main(verbose=None):
- import sys
- test_classes = (
- TestBasic,
- TestVariousIteratorArgs,
- TestSubclass,
- TestSubclassWithKwargs,
- )
- test_support.run_unittest(*test_classes)
- # verify reference counting
- if verbose and hasattr(sys, "gettotalrefcount"):
- import gc
- counts = [None] * 5
- for i in xrange(len(counts)):
- test_support.run_unittest(*test_classes)
- gc.collect()
- counts[i] = sys.gettotalrefcount()
- print counts
- # doctests
- from test import test_deque
- test_support.run_doctest(test_deque, verbose)
- if __name__ == "__main__":
- test_main(verbose=True)