Backward iterators bugfix

src/cython/avl.pyx

@@ -25,7 +25,7 @@ cdef class AvlForwardIterator(object):
 
      def __iter__(self):
          return self
-     
+
      def __next__(self):
          cdef int res
          cdef generic_ptr key = NULL
@@ -41,8 +41,8 @@ cdef class AvlForwardIterator(object):
 cdef class AvlBackwardIterator(object):
      cdef avl.avl_iterator_ptr _iterator
 
-     def __init__(self, obj):
-         self._iterator = avl.avl_iter(<avl_tree_ptr> obj._tree, 1)  # backward
+     def __init__(self, Avl obj):
+         self._iterator = avl.avl_iter(obj._tree, 1)  # backward
          if self._iterator is NULL:
             raise MemoryError()
 
@@ -52,7 +52,7 @@ cdef class AvlBackwardIterator(object):
 
      def __iter__(self):
          return self
-     
+
      def __next__(self):
          cdef int res
          cdef generic_ptr key = NULL
@@ -95,8 +95,8 @@ cdef class Avl(object):
          """C dctor
          """
          assert self._tree is not NULL
-         avl.avl_deinit(self._tree, 
-                        <free_func_ptr> free_callback, 
+         avl.avl_deinit(self._tree,
+                        <free_func_ptr> free_callback,
                         <free_func_ptr> free_callback)
 
 
@@ -120,7 +120,7 @@ cdef class Avl(object):
          assert self._tree is not NULL
 
          if (avl.avl_find(self._tree,
-                          <generic_ptr> key, 
+                          <generic_ptr> key,
                           &value) == 0):
              raise ValueError()
 
@@ -136,27 +136,27 @@ cdef class Avl(object):
          Py_INCREF(value)
 
          avl.avl_insert(self._tree,
-                        <generic_ptr> key, 
+                        <generic_ptr> key,
                         <generic_ptr> value)
 
      def insert(self, object key, object value=None):
-         
+
          assert self._tree is not NULL
 
          # explicit reference counting increment
          Py_INCREF(key)
          Py_INCREF(value)
 
          avl.avl_insert(self._tree,
-                        <generic_ptr> key, 
+                        <generic_ptr> key,
                         <generic_ptr> value)
 
      def __len__(self):
          """__len__() <==> len(T), O(1)
          """
          assert self._tree is not NULL
          return avl.avl_count(self._tree)
-         
+
      def __min__(self):
          """__min__() <==> min(T), get min item (k,v) of T, O(log(n))
          """
@@ -191,7 +191,7 @@ cdef class Avl(object):
          """__or__(other) <==> T | other, union
          """
          pass
-     
+
      def __sub__(self, other):
          """__sub__(other) <==> T - other, difference
          """
@@ -242,7 +242,7 @@ cdef class Avl(object):
          assert self._tree is not NULL
 
          if (avl.avl_find(self._tree,
-                          <generic_ptr> key, 
+                          <generic_ptr> key,
                           &value) == 0):
              return default
 
@@ -267,12 +267,12 @@ cdef class Avl(object):
          try:
              while True:
                  res.append(iter_.next())
-         
+
          except StopIteration:
              pass
 
          return res
-             
+
      def keys(self, reverse=False):
          """keys([reverse]) -> list for keys of T, O(n)
          """
@@ -286,12 +286,12 @@ cdef class Avl(object):
          try:
              while True:
                  res.append(iter_.next()[0])
-         
+
          except StopIteration:
              pass
 
          return res
-             
+
      def values(self, reverse=False):
          """values([reverse]) -> generator for values of T, O(n)
          """
@@ -305,7 +305,7 @@ cdef class Avl(object):
          try:
              while True:
                  res.append(iter_.next()[1])
-         
+
          except StopIteration:
              pass
 
@@ -316,7 +316,7 @@ cdef class Avl(object):
          """
          cdef generic_ptr value = NULL
          assert self._tree is not NULL
-         
+
          if (avl_delete(self._tree,
                         <generic_ptr> key, &value) == 0):
              return
@@ -332,7 +332,7 @@ cdef class Avl(object):
          """
          cdef generic_ptr value = NULL
          assert self._tree is not NULL
-         
+
          if (avl_delete(self._tree,
                         <generic_ptr> key, &value) == 0):
              return default
@@ -349,7 +349,7 @@ cdef class Avl(object):
          """popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple, O(log(n))
          """
          assert self._tree is not NULL
-         
+
          if (avl_delete_pair(self._tree,
                              <generic_ptr> key,
                              <generic_ptr> value) == 0):

test/test_avl.py

@@ -6,7 +6,6 @@ class testAvl(unittest.TestCase):
     """
 
     def setUp(self):
-
         """set up data used in the tests. setUp is called before each
         test function execution.
         """
@@ -19,9 +18,50 @@ def testKeyInsertion(self):
 
     def testKeyValueInsertion(self):
         self.avl_tree.insert(33, "Thirty-three")
-        self.assertTrue(33in self.avl_tree)
+        self.assertTrue(33 in self.avl_tree)
         self.assertEquals(self.avl_tree[33], "Thirty-three")
 
+    def testIntegerOrdering(self):
+        for i in range(99, -1, -1):
+            self.avl_tree.insert(i)
+
+        self.assertEquals(self.avl_tree.keys(), range(0, 100))
+
+    def testLexicographicOrdering(self):
+        strings = [
+            "alpha", "beta", "gamma", "delta", "epsilon", "zeta",
+            "eta", "theta", "iota", "kappa", "lambda", "mu", "nu",
+            "xi", "omicron", "pi", "rho", "sigma", "tau", "upsilon",
+            "phi", "chi", "psi", "omega" ]
+
+        for s in strings:
+            self.avl_tree.insert(s)
+
+        last = None
+        for s in self.avl_tree.keys():
+            self.assertTrue(last is None or last < s)
+            last = s
+
+    def testForwardIterators(self):
+        for i in range(0, 100):
+            self.avl_tree.insert(i, str(i))
+
+        items = iter(self.avl_tree)
+        for (i, k) in zip(xrange(0, 100), items):
+            self.assertEquals(i, k[0])
+            self.assertEquals(str(i), k[1])
+
+    def testBackwardIterators(self):
+        for i in range(0, 100):
+            self.avl_tree.insert(i, str(i))
+
+        items = reversed(self.avl_tree)
+        for (i, k) in zip(xrange(0, 100), items):
+            self.assertEquals(99 - i, k[0])
+            self.assertEquals(str(99 - i), k[1])
+
+
+
     # def testGetFeedPostingURL(self):
 
     #     posting_url = "http://www.avl_tree.com/atom/9276918"