added the tests

tests/70_collections.py

@@ -2,6 +2,7 @@ from collections import Counter, deque
 import random
 import pickle
 import gc
+import builtins
 
 q = deque()
 q.append(1)
@@ -15,16 +16,33 @@ assert q.pop() == 4
 assert len(q) == 2
 assert q == deque([1, 2])
 
-## ADDING TESTS FROM CPYTHON's test_deque.py file
+# ADDING TESTS FROM CPYTHON's test_deque.py file
 
 ############ TEST basics###############
+
+
 def assertEqual(a, b):
     assert a == b
+
+
+def assertNotEqual(a, b):
+    assert a != b
+
+
+def assertRaises(callable, *args, **kwargs):
+    callable(*args, **kwargs)
+    print("X Failed Tests for {} for args: {} {}".format(
+        str(callable), str(args), str(kwargs)))
+
+
 BIG = 100000
+
+
 def fail():
     raise SyntaxError
     yield 1
 
+
 d = deque(range(-5125, -5000))
 d.__init__(range(200))
 for i in range(200, 400):
@@ -128,9 +146,12 @@ try:
 except TypeError:
     pass
 
+
 class BadCompare:
     def __eq__(self, other):
         raise ArithmeticError
+
+
 d = deque([1, 2, BadCompare(), 3])
 
 try:
@@ -148,10 +169,13 @@ try:
 except ArithmeticError:
     pass
 
+
 class MutatingCompare:
     def __eq__(self, other):
         d.pop()
         return True
+
+
 m = MutatingCompare()
 d = deque([1, 2, 3, m, 4, 5])
 m.d = d
@@ -189,7 +213,6 @@ for x in args:
         # assertEqual(x >= y, list(x) >= list(y))   # not currently supported
 
 
-
 ############### TEST contains()#################
 
 n = 200
@@ -204,10 +227,12 @@ class MutateCmp:
     def __init__(self, deque, result):
         self.deque = deque
         self.result = result
+
     def __eq__(self, other):
         self.deque.clear()
         return self.result
 
+
 # # Test detection of mutation during iteration
 d = deque(range(n))
 d[n//2] = MutateCmp(d, False)
@@ -222,6 +247,8 @@ except RuntimeError:
 class BadCmp:
     def __eq__(self, other):
         raise RuntimeError
+
+
 # # Test detection of comparison exceptions
 d = deque(range(n))
 d[n//2] = BadCmp()
@@ -239,6 +266,8 @@ class A:
     def __eq__(self, other):
         d.clear()
         return NotImplemented
+
+
 d = deque([A(), A()])
 
 try:
@@ -436,7 +465,6 @@ for i in range(-len(elements), len(elements)):
         assertEqual(d[i-1], 'Z')
 
 
-
 ######### test set_item #############
 n = 200
 d = deque(range(n))
@@ -645,4 +673,160 @@ for match in (True, False):
         pass
     assertEqual(d, deque())
 
+
+########### test repr#############
+d = deque(range(200))
+e = eval(repr(d))
+assertEqual(list(d), list(e))
+d.append(d)
+assertEqual(repr(d)[-20:], '7, 198, 199, [...]])')
+
+
+######### test init #############
+
+try:
+    deque('abc', 2, 3)
+    print("X Failed Tests!")
+    exit(1)
+except TypeError:
+    pass
+try:
+    deque(1)
+    print("X Failed Tests!")
+    exit(1)
+except TypeError:
+    pass
+
+
+######### test hash #############
+try:
+    assertRaises(hash, deque('abc'))
+except TypeError:
+    pass
+
+
+###### test long steady state queue pop left ########
+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:
+            assertEqual(x, i-size)
+    assertEqual(list(d), list(range(BIG-size, BIG)))
+
+
+######## test long steady state queue pop right ########
+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:
+            assertEqual(x, i-size)
+    assertEqual(list(reversed(list(d))),
+                list(range(BIG-size, BIG)))
+
+###### test big queue popleft ########
+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:
+        assertEqual(x, i)
+
+###### test big queue pop right ########
+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:
+        assertEqual(x, i)
+
+
+####### test big stack right########
+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:
+        assertEqual(x, i)
+assertEqual(len(d), 0)
+
+
+##### test big stack left ########
+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:
+        assertEqual(x, i)
+assertEqual(len(d), 0)
+
+
+##### test roundtrip iter init ########
+d = deque(range(200))
+e = deque(d)
+assertNotEqual(id(d), id(e))
+assertEqual(list(d), list(e))
+
+
+########## test pickle #############
+
+for d in deque(range(200)), deque(range(200), 100):
+    for i in range(5 + 1):
+        s = pickle.dumps(d)
+        e = pickle.loads(s)
+        assertNotEqual(id(e), id(d))
+        assertEqual(list(e), list(d))
+        assertEqual(e.maxlen, d.maxlen)
+
+######## test pickle recursive ########
+# the following doesn't work because the pickle module doesn't
+# for d in deque('abc'), deque('abc', 3):
+#     d.append(d)
+#     for i in range(5 + 1):
+#         e = pickle.loads(pickle.dumps(d))
+#         assertNotEqual(id(e), id(d))
+#         assertEqual(id(e[-1]), id(e))
+#         assertEqual(e.maxlen, d.maxlen)
+
+
+### test copy ########
+
+mut = [10]
+d = deque([mut])
+e = d.copy()
+assertEqual(list(d), list(e))
+mut[0] = 11
+assertNotEqual(id(d), id(e))
+assertEqual(list(d), list(e))
+
+### test reversed#$####
+
+for s in ('abcd', range(2000)):
+    assertEqual(list(reversed(deque(s))), list(reversed(s)))
+
+
+# probably not supported
+# klass = type(reversed(deque()))
+# for s in ('abcd', range(2000)):
+#     assertEqual(list(klass(deque(s))), list(reversed(s)))
+
+d = deque()
+for i in range(100):
+    d.append(1)
+    gc.collect()
+
+
 print('✓', "ALL TEST PASSED!!")