| from collections import deque |
| import unittest |
| from test import support, seq_tests |
| import gc |
| import weakref |
| import copy |
| import pickle |
| from io import StringIO |
| import random |
| import struct |
| |
| 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(range(-5125, -5000)) |
| d.__init__(range(200)) |
| for i in range(200, 400): |
| d.append(i) |
| for i in reversed(range(-200, 0)): |
| d.appendleft(i) |
| self.assertEqual(list(d), list(range(-200, 400))) |
| self.assertEqual(len(d), 600) |
| |
| left = [d.popleft() for i in range(250)] |
| self.assertEqual(left, list(range(-200, 50))) |
| self.assertEqual(list(d), list(range(50, 400))) |
| |
| right = [d.pop() for i in range(250)] |
| right.reverse() |
| self.assertEqual(right, list(range(150, 400))) |
| self.assertEqual(list(d), list(range(50, 150))) |
| |
| def test_maxlen(self): |
| self.assertRaises(ValueError, deque, 'abc', -1) |
| self.assertRaises(ValueError, deque, 'abc', -2) |
| it = iter(range(10)) |
| d = deque(it, maxlen=3) |
| self.assertEqual(list(it), []) |
| self.assertEqual(repr(d), 'deque([7, 8, 9], maxlen=3)') |
| self.assertEqual(list(d), [7, 8, 9]) |
| self.assertEqual(d, deque(range(10), 3)) |
| d.append(10) |
| self.assertEqual(list(d), [8, 9, 10]) |
| d.appendleft(7) |
| self.assertEqual(list(d), [7, 8, 9]) |
| d.extend([10, 11]) |
| self.assertEqual(list(d), [9, 10, 11]) |
| d.extendleft([8, 7]) |
| self.assertEqual(list(d), [7, 8, 9]) |
| d = deque(range(200), maxlen=10) |
| d.append(d) |
| support.unlink(support.TESTFN) |
| fo = open(support.TESTFN, "w") |
| try: |
| fo.write(str(d)) |
| fo.close() |
| fo = open(support.TESTFN, "r") |
| self.assertEqual(fo.read(), repr(d)) |
| finally: |
| fo.close() |
| support.unlink(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(support.TESTFN, "w") |
| try: |
| fo.write(str(d)) |
| fo.close() |
| fo = open(support.TESTFN, "r") |
| self.assertEqual(fo.read(), repr(d)) |
| finally: |
| fo.close() |
| support.unlink(support.TESTFN) |
| |
| def test_maxlen_zero(self): |
| it = iter(range(100)) |
| deque(it, maxlen=0) |
| self.assertEqual(list(it), []) |
| |
| it = iter(range(100)) |
| d = deque(maxlen=0) |
| d.extend(it) |
| self.assertEqual(list(it), []) |
| |
| it = iter(range(100)) |
| d = deque(maxlen=0) |
| d.extendleft(it) |
| self.assertEqual(list(it), []) |
| |
| def test_maxlen_attribute(self): |
| self.assertEqual(deque().maxlen, None) |
| self.assertEqual(deque('abc').maxlen, None) |
| self.assertEqual(deque('abc', maxlen=4).maxlen, 4) |
| self.assertEqual(deque('abc', maxlen=2).maxlen, 2) |
| self.assertEqual(deque('abc', maxlen=0).maxlen, 0) |
| with self.assertRaises(AttributeError): |
| d = deque('abc') |
| d.maxlen = 10 |
| |
| def test_count(self): |
| for s in ('', 'abracadabra', 'simsalabim'*500+'abc'): |
| s = list(s) |
| d = deque(s) |
| for letter in 'abcdefghijklmnopqrstuvwxyz': |
| self.assertEqual(s.count(letter), d.count(letter), (s, d, letter)) |
| self.assertRaises(TypeError, d.count) # too few args |
| self.assertRaises(TypeError, d.count, 1, 2) # too many args |
| class BadCompare: |
| def __eq__(self, other): |
| raise ArithmeticError |
| d = deque([1, 2, BadCompare(), 3]) |
| self.assertRaises(ArithmeticError, d.count, 2) |
| d = deque([1, 2, 3]) |
| self.assertRaises(ArithmeticError, d.count, BadCompare()) |
| class MutatingCompare: |
| def __eq__(self, other): |
| self.d.pop() |
| return True |
| m = MutatingCompare() |
| d = deque([1, 2, 3, m, 4, 5]) |
| m.d = d |
| self.assertRaises(RuntimeError, d.count, 3) |
| |
| # test issue11004 |
| # block advance failed after rotation aligned elements on right side of block |
| d = deque([None]*16) |
| for i in range(len(d)): |
| d.rotate(-1) |
| d.rotate(1) |
| self.assertEqual(d.count(1), 0) |
| self.assertEqual(d.count(None), 16) |
| |
| 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)) |
| |
| def test_contains(self): |
| n = 200 |
| |
| d = deque(range(n)) |
| for i in range(n): |
| self.assertTrue(i in d) |
| self.assertTrue((n+1) not in d) |
| |
| # Test detection of mutation during iteration |
| d = deque(range(n)) |
| d[n//2] = MutateCmp(d, False) |
| with self.assertRaises(RuntimeError): |
| n in d |
| |
| # Test detection of comparison exceptions |
| d = deque(range(n)) |
| d[n//2] = BadCmp() |
| with self.assertRaises(RuntimeError): |
| n in d |
| |
| def test_extend(self): |
| d = deque('a') |
| self.assertRaises(TypeError, d.extend, 1) |
| d.extend('bcd') |
| self.assertEqual(list(d), list('abcd')) |
| d.extend(d) |
| self.assertEqual(list(d), list('abcdabcd')) |
| |
| def test_add(self): |
| d = deque() |
| e = deque('abc') |
| f = deque('def') |
| self.assertEqual(d + d, deque()) |
| self.assertEqual(e + f, deque('abcdef')) |
| self.assertEqual(e + e, deque('abcabc')) |
| self.assertEqual(e + d, deque('abc')) |
| self.assertEqual(d + e, deque('abc')) |
| self.assertIsNot(d + d, deque()) |
| self.assertIsNot(e + d, deque('abc')) |
| self.assertIsNot(d + e, deque('abc')) |
| |
| g = deque('abcdef', maxlen=4) |
| h = deque('gh') |
| self.assertEqual(g + h, deque('efgh')) |
| |
| with self.assertRaises(TypeError): |
| deque('abc') + 'def' |
| |
| def test_iadd(self): |
| d = deque('a') |
| d += 'bcd' |
| self.assertEqual(list(d), list('abcd')) |
| d += d |
| self.assertEqual(list(d), list('abcdabcd')) |
| |
| def test_extendleft(self): |
| d = deque('a') |
| self.assertRaises(TypeError, d.extendleft, 1) |
| d.extendleft('bcd') |
| self.assertEqual(list(d), list(reversed('abcd'))) |
| d.extendleft(d) |
| self.assertEqual(list(d), list('abcddcba')) |
| 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(range(n)) |
| l = list(range(n)) |
| for i in range(n): |
| d.popleft() |
| l.pop(0) |
| if random.random() < 0.5: |
| d.append(i) |
| l.append(i) |
| for j in range(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_index(self): |
| for n in 1, 2, 30, 40, 200: |
| |
| d = deque(range(n)) |
| for i in range(n): |
| self.assertEqual(d.index(i), i) |
| |
| with self.assertRaises(ValueError): |
| d.index(n+1) |
| |
| # Test detection of mutation during iteration |
| d = deque(range(n)) |
| d[n//2] = MutateCmp(d, False) |
| with self.assertRaises(RuntimeError): |
| d.index(n) |
| |
| # Test detection of comparison exceptions |
| d = deque(range(n)) |
| d[n//2] = BadCmp() |
| with self.assertRaises(RuntimeError): |
| d.index(n) |
| |
| # Test start and stop arguments behavior matches list.index() |
| elements = 'ABCDEFGHI' |
| nonelement = 'Z' |
| d = deque(elements * 2) |
| s = list(elements * 2) |
| for start in range(-5 - len(s)*2, 5 + len(s) * 2): |
| for stop in range(-5 - len(s)*2, 5 + len(s) * 2): |
| for element in elements + 'Z': |
| try: |
| target = s.index(element, start, stop) |
| except ValueError: |
| with self.assertRaises(ValueError): |
| d.index(element, start, stop) |
| else: |
| self.assertEqual(d.index(element, start, stop), target) |
| |
| def test_index_bug_24913(self): |
| d = deque('A' * 3) |
| with self.assertRaises(ValueError): |
| i = d.index("Hello world", 0, 4) |
| |
| def test_insert(self): |
| # Test to make sure insert behaves like lists |
| elements = 'ABCDEFGHI' |
| for i in range(-5 - len(elements)*2, 5 + len(elements) * 2): |
| d = deque('ABCDEFGHI') |
| s = list('ABCDEFGHI') |
| d.insert(i, 'Z') |
| s.insert(i, 'Z') |
| self.assertEqual(list(d), s) |
| |
| def test_insert_bug_26194(self): |
| data = 'ABC' |
| d = deque(data, maxlen=len(data)) |
| with self.assertRaises(IndexError): |
| d.insert(2, None) |
| |
| elements = 'ABCDEFGHI' |
| for i in range(-len(elements), len(elements)): |
| d = deque(elements, maxlen=len(elements)+1) |
| d.insert(i, 'Z') |
| if i >= 0: |
| self.assertEqual(d[i], 'Z') |
| else: |
| self.assertEqual(d[i-1], 'Z') |
| |
| def test_imul(self): |
| for n in (-10, -1, 0, 1, 2, 10, 1000): |
| d = deque() |
| d *= n |
| self.assertEqual(d, deque()) |
| self.assertIsNone(d.maxlen) |
| |
| for n in (-10, -1, 0, 1, 2, 10, 1000): |
| d = deque('a') |
| d *= n |
| self.assertEqual(d, deque('a' * n)) |
| self.assertIsNone(d.maxlen) |
| |
| for n in (-10, -1, 0, 1, 2, 10, 499, 500, 501, 1000): |
| d = deque('a', 500) |
| d *= n |
| self.assertEqual(d, deque('a' * min(n, 500))) |
| self.assertEqual(d.maxlen, 500) |
| |
| for n in (-10, -1, 0, 1, 2, 10, 1000): |
| d = deque('abcdef') |
| d *= n |
| self.assertEqual(d, deque('abcdef' * n)) |
| self.assertIsNone(d.maxlen) |
| |
| for n in (-10, -1, 0, 1, 2, 10, 499, 500, 501, 1000): |
| d = deque('abcdef', 500) |
| d *= n |
| self.assertEqual(d, deque(('abcdef' * n)[-500:])) |
| self.assertEqual(d.maxlen, 500) |
| |
| def test_mul(self): |
| d = deque('abc') |
| self.assertEqual(d * -5, deque()) |
| self.assertEqual(d * 0, deque()) |
| self.assertEqual(d * 1, deque('abc')) |
| self.assertEqual(d * 2, deque('abcabc')) |
| self.assertEqual(d * 3, deque('abcabcabc')) |
| self.assertIsNot(d * 1, d) |
| |
| self.assertEqual(deque() * 0, deque()) |
| self.assertEqual(deque() * 1, deque()) |
| self.assertEqual(deque() * 5, deque()) |
| |
| self.assertEqual(-5 * d, deque()) |
| self.assertEqual(0 * d, deque()) |
| self.assertEqual(1 * d, deque('abc')) |
| self.assertEqual(2 * d, deque('abcabc')) |
| self.assertEqual(3 * d, deque('abcabcabc')) |
| |
| d = deque('abc', maxlen=5) |
| self.assertEqual(d * -5, deque()) |
| self.assertEqual(d * 0, deque()) |
| self.assertEqual(d * 1, deque('abc')) |
| self.assertEqual(d * 2, deque('bcabc')) |
| self.assertEqual(d * 30, deque('bcabc')) |
| |
| def test_setitem(self): |
| n = 200 |
| d = deque(range(n)) |
| for i in range(n): |
| d[i] = 10 * i |
| self.assertEqual(list(d), [10*i for i in range(n)]) |
| l = list(d) |
| for i in range(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(range(n)) |
| self.assertRaises(IndexError, d.__delitem__, -n-1) |
| self.assertRaises(IndexError, d.__delitem__, n) |
| for i in range(n): |
| self.assertEqual(len(d), n-i) |
| j = random.randrange(-len(d), len(d)) |
| val = d[j] |
| self.assertIn(val, d) |
| del d[j] |
| self.assertNotIn(val, d) |
| self.assertEqual(len(d), 0) |
| |
| def test_reverse(self): |
| n = 500 # O(n**2) test, don't make this too big |
| data = [random.random() for i in range(n)] |
| for i in range(n): |
| d = deque(data[:i]) |
| r = d.reverse() |
| self.assertEqual(list(d), list(reversed(data[:i]))) |
| self.assertIs(r, None) |
| d.reverse() |
| self.assertEqual(list(d), data[:i]) |
| self.assertRaises(TypeError, d.reverse, 1) # Arity is zero |
| |
| 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 range(n*3): |
| d = deque(s) |
| e = deque(d) |
| d.rotate(i) # check vs. rot(1) n times |
| for j in range(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 range(n*3): |
| d = deque(s) |
| e = deque(d) |
| d.rotate(-i) |
| for j in range(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 range(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(range(100)) |
| self.assertEqual(len(d), 100) |
| d.clear() |
| self.assertEqual(len(d), 0) |
| self.assertEqual(list(d), []) |
| d.clear() # clear an empty 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.assertTrue(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(range(200)) |
| e = eval(repr(d)) |
| self.assertEqual(list(d), list(e)) |
| d.append(d) |
| self.assertIn('...', repr(d)) |
| |
| def test_print(self): |
| d = deque(range(200)) |
| d.append(d) |
| try: |
| support.unlink(support.TESTFN) |
| fo = open(support.TESTFN, "w") |
| print(d, file=fo, end='') |
| fo.close() |
| fo = open(support.TESTFN, "r") |
| self.assertEqual(fo.read(), repr(d)) |
| finally: |
| fo.close() |
| support.unlink(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(range(size)) |
| append, pop = d.append, d.popleft |
| for i in range(size, BIG): |
| append(i) |
| x = pop() |
| if x != i - size: |
| self.assertEqual(x, i-size) |
| self.assertEqual(list(d), list(range(BIG-size, BIG))) |
| |
| def test_long_steadystate_queue_popright(self): |
| for size in (0, 1, 2, 100, 1000): |
| d = deque(reversed(range(size))) |
| append, pop = d.appendleft, d.pop |
| for i in range(size, BIG): |
| append(i) |
| x = pop() |
| if x != i - size: |
| self.assertEqual(x, i-size) |
| self.assertEqual(list(reversed(list(d))), |
| list(range(BIG-size, BIG))) |
| |
| def test_big_queue_popleft(self): |
| pass |
| d = deque() |
| append, pop = d.append, d.popleft |
| for i in range(BIG): |
| append(i) |
| for i in range(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 range(BIG): |
| append(i) |
| for i in range(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 range(BIG): |
| append(i) |
| for i in reversed(range(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 range(BIG): |
| append(i) |
| for i in reversed(range(BIG)): |
| x = pop() |
| if x != i: |
| self.assertEqual(x, i) |
| self.assertEqual(len(d), 0) |
| |
| def test_roundtrip_iter_init(self): |
| d = deque(range(200)) |
| e = deque(d) |
| self.assertNotEqual(id(d), id(e)) |
| self.assertEqual(list(d), list(e)) |
| |
| def test_pickle(self): |
| for d in deque(range(200)), deque(range(200), 100): |
| for i in range(pickle.HIGHEST_PROTOCOL + 1): |
| s = pickle.dumps(d, i) |
| e = pickle.loads(s) |
| self.assertNotEqual(id(e), id(d)) |
| self.assertEqual(list(e), list(d)) |
| self.assertEqual(e.maxlen, d.maxlen) |
| |
| def test_pickle_recursive(self): |
| for d in deque('abc'), deque('abc', 3): |
| d.append(d) |
| for i in range(pickle.HIGHEST_PROTOCOL + 1): |
| e = pickle.loads(pickle.dumps(d, i)) |
| self.assertNotEqual(id(e), id(d)) |
| self.assertEqual(id(e[-1]), id(e)) |
| self.assertEqual(e.maxlen, d.maxlen) |
| |
| def test_iterator_pickle(self): |
| orig = deque(range(200)) |
| data = [i*1.01 for i in orig] |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| # initial iterator |
| itorg = iter(orig) |
| dump = pickle.dumps((itorg, orig), proto) |
| it, d = pickle.loads(dump) |
| for i, x in enumerate(data): |
| d[i] = x |
| self.assertEqual(type(it), type(itorg)) |
| self.assertEqual(list(it), data) |
| |
| # running iterator |
| next(itorg) |
| dump = pickle.dumps((itorg, orig), proto) |
| it, d = pickle.loads(dump) |
| for i, x in enumerate(data): |
| d[i] = x |
| self.assertEqual(type(it), type(itorg)) |
| self.assertEqual(list(it), data[1:]) |
| |
| # empty iterator |
| for i in range(1, len(data)): |
| next(itorg) |
| dump = pickle.dumps((itorg, orig), proto) |
| it, d = pickle.loads(dump) |
| for i, x in enumerate(data): |
| d[i] = x |
| self.assertEqual(type(it), type(itorg)) |
| self.assertEqual(list(it), []) |
| |
| # exhausted iterator |
| self.assertRaises(StopIteration, next, itorg) |
| dump = pickle.dumps((itorg, orig), proto) |
| it, d = pickle.loads(dump) |
| for i, x in enumerate(data): |
| d[i] = x |
| self.assertEqual(type(it), type(itorg)) |
| self.assertEqual(list(it), []) |
| |
| 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)) |
| |
| for i in range(5): |
| for maxlen in range(-1, 6): |
| s = [random.random() for j in range(i)] |
| d = deque(s) if maxlen == -1 else deque(s, maxlen) |
| e = d.copy() |
| self.assertEqual(d, e) |
| self.assertEqual(d.maxlen, e.maxlen) |
| self.assertTrue(all(x is y for x, y in zip(d, e))) |
| |
| def test_copy_method(self): |
| mut = [10] |
| d = deque([mut]) |
| e = d.copy() |
| 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', range(2000)): |
| self.assertEqual(list(reversed(deque(s))), list(reversed(s))) |
| |
| def test_reversed_new(self): |
| klass = type(reversed(deque())) |
| for s in ('abcd', range(2000)): |
| self.assertEqual(list(klass(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 range(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.assertTrue(ref() is None, "Cycle was not collected") |
| |
| check_sizeof = support.check_sizeof |
| |
| @support.cpython_only |
| def test_sizeof(self): |
| BLOCKLEN = 64 |
| basesize = support.calcvobjsize('2P4nP') |
| blocksize = struct.calcsize('P%dPP' % BLOCKLEN) |
| self.assertEqual(object.__sizeof__(deque()), basesize) |
| check = self.check_sizeof |
| check(deque(), basesize + blocksize) |
| check(deque('a'), basesize + blocksize) |
| check(deque('a' * (BLOCKLEN - 1)), basesize + blocksize) |
| check(deque('a' * BLOCKLEN), basesize + 2 * blocksize) |
| check(deque('a' * (42 * BLOCKLEN)), basesize + 43 * blocksize) |
| |
| class TestVariousIteratorArgs(unittest.TestCase): |
| |
| def test_constructor(self): |
| for s in ("123", "", range(1000), ('do', 1.2), range(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, next, it) |
| |
| def test_runtime_error_on_empty_deque(self): |
| d = deque() |
| it = iter(d) |
| d.append(10) |
| self.assertRaises(RuntimeError, next, it) |
| |
| class Deque(deque): |
| pass |
| |
| class DequeWithBadIter(deque): |
| def __iter__(self): |
| raise TypeError |
| |
| class TestSubclass(unittest.TestCase): |
| |
| def test_basics(self): |
| d = Deque(range(25)) |
| d.__init__(range(200)) |
| for i in range(200, 400): |
| d.append(i) |
| for i in reversed(range(-200, 0)): |
| d.appendleft(i) |
| self.assertEqual(list(d), list(range(-200, 400))) |
| self.assertEqual(len(d), 600) |
| |
| left = [d.popleft() for i in range(250)] |
| self.assertEqual(left, list(range(-200, 50))) |
| self.assertEqual(list(d), list(range(50, 400))) |
| |
| right = [d.pop() for i in range(250)] |
| right.reverse() |
| self.assertEqual(right, list(range(150, 400))) |
| self.assertEqual(list(d), list(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)) |
| |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| s = pickle.dumps(d, proto) |
| 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)) |
| |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| s = pickle.dumps(d, proto) |
| 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_recursive(self): |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| for d in Deque('abc'), Deque('abc', 3): |
| d.append(d) |
| |
| e = pickle.loads(pickle.dumps(d, proto)) |
| self.assertNotEqual(id(e), id(d)) |
| self.assertEqual(type(e), type(d)) |
| self.assertEqual(e.maxlen, d.maxlen) |
| dd = d.pop() |
| ee = e.pop() |
| self.assertEqual(id(ee), id(e)) |
| self.assertEqual(e, d) |
| |
| d.x = d |
| e = pickle.loads(pickle.dumps(d, proto)) |
| self.assertEqual(id(e.x), id(e)) |
| |
| for d in DequeWithBadIter('abc'), DequeWithBadIter('abc', 2): |
| self.assertRaises(TypeError, pickle.dumps, d, proto) |
| |
| 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) |
| |
| class TestSequence(seq_tests.CommonTest): |
| type2test = deque |
| |
| def test_getitem(self): |
| # For now, bypass tests that require slicing |
| pass |
| |
| def test_getslice(self): |
| # For now, bypass tests that require slicing |
| pass |
| |
| def test_subscript(self): |
| # For now, bypass tests that require slicing |
| pass |
| |
| def test_free_after_iterating(self): |
| # For now, bypass tests that require slicing |
| self.skipTest("Exhausted deque iterator doesn't free a deque") |
| |
| #============================================================================== |
| |
| 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 next(task) |
| ... 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, |
| TestSequence, |
| ) |
| |
| support.run_unittest(*test_classes) |
| |
| # verify reference counting |
| if verbose and hasattr(sys, "gettotalrefcount"): |
| import gc |
| counts = [None] * 5 |
| for i in range(len(counts)): |
| support.run_unittest(*test_classes) |
| gc.collect() |
| counts[i] = sys.gettotalrefcount() |
| print(counts) |
| |
| # doctests |
| from test import test_deque |
| support.run_doctest(test_deque, verbose) |
| |
| if __name__ == "__main__": |
| test_main(verbose=True) |
