Merge pull request #129 from bradmwalker/range-fixes

newrange equality and slicing fixed

Author: edschofield

src/future/types/newrange.py

@@ -1,5 +1,5 @@
 """
-Nearly identical to xrange.py, by Dan Crosta, from 
+Nearly identical to xrange.py, by Dan Crosta, from
 
     https://github.com/dcrosta/xrange.git
 
@@ -18,11 +18,8 @@
         https://late.am/post/2012/06/18/what-the-heck-is-an-xrange
 """
 
-from math import ceil
 from collections import Sequence, Iterator
 
-from future.utils import PY3
-
 
 class newrange(Sequence):
     """
@@ -64,10 +61,10 @@ def __repr__(self):
         return 'range(%d, %d, %d)' % (self._start, self._stop, self._step)
 
     def __eq__(self, other):
-        return isinstance(other, newrange) and \
-               self._start == other._start and \
-               self._stop == other._stop and \
-               self._step == other._step
+        return (isinstance(other, newrange) and
+                (self._len == 0 == other._len or
+                 (self._start, self._step, self._len) ==
+                 (other._start, other._step, self._len)))
 
     def __len__(self):
         return self._len
@@ -121,23 +118,8 @@ def __getitem_slice(self, slce):
         """Return a range which represents the requested slce
         of the sequence represented by this range.
         """
-        start, stop, step = slce.start, slce.stop, slce.step
-        if step == 0:
-            raise ValueError('slice step cannot be 0')
-
-        start = start or self._start
-        stop = stop or self._stop
-        if start < 0:
-            start = max(0, start + self._len)
-        if stop < 0:
-            stop = max(start, stop + self._len)
-
-        if step is None or step > 0:
-            return newrange(start, stop, step or 1)
-        else:
-            rv = reversed(self)
-            rv._step = step
-            return rv
+        start, stop, step = slce.indices(self._len)
+        return newrange(self[start], stop + self._start, step * self._step)
 
     def __iter__(self):
         """Return an iterator which enumerates the elements of the

tests/test_future/test_range.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for the backported class:`range` class.
+"""
+
+from future.builtins import range
+from future.tests.base import unittest
+
+from collections import Sequence
+
+
+class RangeTests(unittest.TestCase):
+    def test_range(self):
+        self.assertTrue(isinstance(range(0), Sequence))
+
+    def test_bool_range(self):
+        self.assertFalse(range(0))
+        self.assertTrue(range(1))
+        self.assertFalse(range(1, 1))
+        self.assertFalse(range(5, 2))
+
+    def test_equality(self):
+        self.assertEqual(range(7), range(7))
+        self.assertEqual(range(0), range(1, 1))
+        self.assertEqual(range(0, 10, 3), range(0, 11, 3))
+
+    def test_slice_range(self):
+        r = range(8)
+        self.assertEqual(r[:], range(8))
+        self.assertEqual(r[:2], range(2))
+        self.assertEqual(r[:-2], range(6))
+        self.assertEqual(r[2:], range(2, 8))
+        self.assertEqual(r[-2:], range(6, 8))
+        self.assertEqual(r[2:-2], range(2, 6))
+        self.assertEqual(r[-2:2:-1], range(6, 2, -1))
+        r = r[::-1]
+        self.assertEqual(r, range(7, -1, -1))
+        self.assertEqual(r[:], range(7, -1, -1))
+        self.assertEqual(r[:2], range(7, 5, -1))
+        self.assertEqual(r[:-2], range(7, 1, -1))
+        self.assertEqual(r[2:], range(5, -1, -1))
+        self.assertEqual(r[-2:], range(1, -1, -1))
+        self.assertEqual(r[2:-2], range(5, 1, -1))
+        self.assertEqual(r[-2:2:-1], range(1, 5))
+
+    def test_slice_offsetted_range(self):
+        r = range(4, 16)
+        self.assertEqual(r[:], range(4, 16))
+        self.assertEqual(r[::-1], range(15, 3, -1))
+        self.assertEqual(r[:4], range(4, 8))
+        self.assertEqual(r[:-4], range(4, 12))
+        self.assertEqual(r[4:], range(8, 16))
+        self.assertEqual(r[-4:], range(12, 16))
+        self.assertEqual(r[4:-4], range(8, 12))
+        self.assertEqual(r[-4:4:-1], range(12, 8, -1))
+
+    def test_slice_overflow_range(self):
+        r = range(8)
+        self.assertEqual(r[2:200], range(2, 8))
+        self.assertEqual(r[-200:-2], range(0, 6))
+
+    def test_stepped_slice_range(self):
+        r = range(8)
+        self.assertEqual(r[::2], range(0, 8, 2))
+        self.assertEqual(r[::-2], range(7, -1, -2))
+        self.assertEqual(r[:2:2], range(0, 2, 2))
+        self.assertEqual(r[:-2:2], range(0, 6, 2))
+        self.assertEqual(r[2::2], range(2, 8, 2))
+        self.assertEqual(r[-2::2], range(6, 8, 2))
+        self.assertEqual(r[2:-2:2], range(2, 6, 2))
+
+    def test_stepped_slice_stepped_range(self):
+        r = range(0, 16, 2)
+        self.assertEqual(r[::2], range(0, 16, 4))
+        self.assertEqual(r[:2:2], range(0, 4, 4))
+        self.assertEqual(r[:-2:2], range(0, 12, 4))
+        self.assertEqual(r[2::2], range(4, 16, 4))
+        self.assertEqual(r[-2::2], range(12, 16, 4))
+        self.assertEqual(r[2:-2:2], range(4, 12, 4))
+
+    def test_rev_slice_range(self):
+        r = range(8)
+        self.assertEqual(r[::-1], range(7, -1, -1))
+        self.assertEqual(r[:2:-1], range(7, 2, -1))
+        self.assertEqual(r[:-2:-1], range(7, 6, -1))
+        self.assertEqual(r[2::-1], range(2, -1, -1))
+        self.assertEqual(r[-2::-1], range(6, -1, -1))
+        self.assertEqual(r[-2:2:-1], range(6, 2, -1))
+        r = range(0, 16, 2)
+        self.assertEqual(r[::-2], range(14, -2, -4))
+        self.assertEqual(r[:2:-2], range(14, 4, -4))
+        self.assertEqual(r[:-2:-2], range(14, 12, -4))
+        self.assertEqual(r[2::-2], range(4, -2, -4))
+        self.assertEqual(r[-2::-2], range(12, -2, -4))
+        self.assertEqual(r[-2:2:-2], range(12, 4, -4))
+
+    def test_slice_zero_step(self):
+        msg = '^slice step cannot be zero$'
+        with self.assertRaisesRegexp(ValueError, msg):
+            range(8)[::0]
+
+
+if __name__ == '__main__':
+    unittest.main()