from collections import deque

import unittest

from test import test_support, seq_tests

from weakref import proxy

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 (0, 1, 2):

            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 (0, 1, 2):

##            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()

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)