[pypy-commit] pypy py3k: rename xrange() to range(), and remove pypy's RangeList
amauryfa
noreply at buildbot.pypy.org
Wed Oct 12 22:23:29 CEST 2011
Author: Amaury Forgeot d'Arc <amauryfa at gmail.com>
Branch: py3k
Changeset: r47989:fea44485fe72
Date: 2011-10-12 22:19 +0200
http://bitbucket.org/pypy/pypy/changeset/fea44485fe72/
Log: rename xrange() to range(), and remove pypy's RangeList
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -275,12 +275,6 @@
("objspace.std.withmethodcache", True),
]),
- BoolOption("withrangelist",
- "enable special range list implementation that does not "
- "actually create the full list until the resulting "
- "list is mutated",
- default=False),
-
BoolOption("withtypeversion",
"version type objects when changing them",
cmdline=None,
diff --git a/pypy/doc/config/objspace.std.withrangelist.txt b/pypy/doc/config/objspace.std.withrangelist.txt
deleted file mode 100644
--- a/pypy/doc/config/objspace.std.withrangelist.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-Enable "range list" objects. They are an additional implementation of the Python
-``list`` type, indistinguishable for the normal user. Whenever the ``range``
-builtin is called, an range list is returned. As long as this list is not
-mutated (and for example only iterated over), it uses only enough memory to
-store the start, stop and step of the range. This makes using ``range`` as
-efficient as ``xrange``, as long as the result is only used in a ``for``-loop.
-
-See the section in `Standard Interpreter Optimizations`_ for more details.
-
-.. _`Standard Interpreter Optimizations`: ../interpreter-optimizations.html#range-lists
-
diff --git a/pypy/module/__builtin__/__init__.py b/pypy/module/__builtin__/__init__.py
--- a/pypy/module/__builtin__/__init__.py
+++ b/pypy/module/__builtin__/__init__.py
@@ -83,8 +83,7 @@
'__import__' : 'pypy.module.imp.importing.importhook',
'reload' : 'pypy.module.imp.importing.reload',
- 'range' : 'functional.range_int',
- 'xrange' : 'functional.W_XRange',
+ 'range' : 'functional.W_Range',
'enumerate' : 'functional.W_Enumerate',
'min' : 'functional.min',
'max' : 'functional.max',
diff --git a/pypy/module/__builtin__/functional.py b/pypy/module/__builtin__/functional.py
--- a/pypy/module/__builtin__/functional.py
+++ b/pypy/module/__builtin__/functional.py
@@ -15,7 +15,7 @@
def get_len_of_range(space, lo, hi, step):
"""
- Return number of items in range/xrange (lo, hi, step).
+ Return number of items in range (lo, hi, step).
Raise ValueError if step == 0 and OverflowError if the true value is too
large to fit in a signed long.
"""
@@ -47,91 +47,6 @@
n = 0
return n
-def range_int(space, w_x, w_y=NoneNotWrapped, w_step=1):
- """Return a list of integers in arithmetic position from start (defaults
-to zero) to stop - 1 by step (defaults to 1). Use a negative step to
-get a list in decending order."""
-
- if w_y is None:
- w_start = space.wrap(0)
- w_stop = w_x
- else:
- w_start = w_x
- w_stop = w_y
-
- if space.is_true(space.isinstance(w_stop, space.w_float)):
- raise OperationError(space.w_TypeError,
- space.wrap("range() integer end argument expected, got float."))
- if space.is_true(space.isinstance(w_start, space.w_float)):
- raise OperationError(space.w_TypeError,
- space.wrap("range() integer start argument expected, got float."))
- if space.is_true(space.isinstance(w_step, space.w_float)):
- raise OperationError(space.w_TypeError,
- space.wrap("range() integer step argument expected, got float."))
-
- w_start = space.int(w_start)
- w_stop = space.int(w_stop)
- w_step = space.int(w_step)
-
- try:
- start = space.int_w(w_start)
- stop = space.int_w(w_stop)
- step = space.int_w(w_step)
- except OperationError, e:
- if not e.match(space, space.w_OverflowError):
- raise
- return range_with_longs(space, w_start, w_stop, w_step)
-
- howmany = get_len_of_range(space, start, stop, step)
-
- if space.config.objspace.std.withrangelist:
- return range_withspecialized_implementation(space, start,
- step, howmany)
- res_w = [None] * howmany
- v = start
- for idx in range(howmany):
- res_w[idx] = space.wrap(v)
- v += step
- return space.newlist(res_w)
-
-
-def range_withspecialized_implementation(space, start, step, howmany):
- assert space.config.objspace.std.withrangelist
- from pypy.objspace.std.rangeobject import W_RangeListObject
- return W_RangeListObject(start, step, howmany)
-
-bigint_one = rbigint.fromint(1)
-
-def range_with_longs(space, w_start, w_stop, w_step):
-
- start = lo = space.bigint_w(w_start)
- stop = hi = space.bigint_w(w_stop)
- step = st = space.bigint_w(w_step)
-
- if not step.tobool():
- raise OperationError(space.w_ValueError,
- space.wrap("step argument must not be zero"))
- elif step.sign < 0:
- lo, hi, st = hi, lo, st.neg()
-
- if lo.lt(hi):
- diff = hi.sub(lo).sub(bigint_one)
- n = diff.floordiv(st).add(bigint_one)
- try:
- howmany = n.toint()
- except OverflowError:
- raise OperationError(space.w_OverflowError,
- space.wrap("result has too many items"))
- else:
- howmany = 0
-
- res_w = [None] * howmany
- v = start
- for idx in range(howmany):
- res_w[idx] = space.newlong_from_rbigint(v)
- v = v.add(step)
- return space.newlist(res_w)
-
@specialize.arg(2)
@jit.look_inside_iff(lambda space, args, implementation_of:
@@ -528,7 +443,7 @@
-class W_XRange(Wrappable):
+class W_Range(Wrappable):
def __init__(self, space, start, len, step):
self.space = space
self.start = start
@@ -543,18 +458,18 @@
else:
stop = _toint(space, w_stop)
howmany = get_len_of_range(space, start, stop, step)
- obj = space.allocate_instance(W_XRange, w_subtype)
- W_XRange.__init__(obj, space, start, howmany, step)
+ obj = space.allocate_instance(W_Range, w_subtype)
+ W_Range.__init__(obj, space, start, howmany, step)
return space.wrap(obj)
def descr_repr(self):
stop = self.start + self.len * self.step
if self.start == 0 and self.step == 1:
- s = "xrange(%d)" % (stop,)
+ s = "range(%d)" % (stop,)
elif self.step == 1:
- s = "xrange(%d, %d)" % (self.start, stop)
+ s = "range(%d, %d)" % (self.start, stop)
else:
- s = "xrange(%d, %d, %d)" %(self.start, stop, self.step)
+ s = "range(%d, %d, %d)" %(self.start, stop, self.step)
return self.space.wrap(s)
def descr_len(self):
@@ -562,7 +477,7 @@
@unwrap_spec(i='index')
def descr_getitem(self, i):
- # xrange does NOT support slicing
+ # range does NOT support slicing
space = self.space
len = self.len
if i < 0:
@@ -570,15 +485,15 @@
if 0 <= i < len:
return space.wrap(self.start + i * self.step)
raise OperationError(space.w_IndexError,
- space.wrap("xrange object index out of range"))
+ space.wrap("range object index out of range"))
def descr_iter(self):
- return self.space.wrap(W_XRangeIterator(self.space, self.start,
+ return self.space.wrap(W_RangeIterator(self.space, self.start,
self.len, self.step))
def descr_reversed(self):
lastitem = self.start + (self.len-1) * self.step
- return self.space.wrap(W_XRangeIterator(self.space, lastitem,
+ return self.space.wrap(W_RangeIterator(self.space, lastitem,
self.len, -self.step))
def descr_reduce(self):
@@ -591,21 +506,19 @@
])
def _toint(space, w_obj):
- # this also supports float arguments. CPython still does, too.
- # needs a bit more thinking in general...
- return space.int_w(space.int(w_obj))
+ return space.int_w(space.index(w_obj))
-W_XRange.typedef = TypeDef("xrange",
- __new__ = interp2app(W_XRange.descr_new.im_func),
- __repr__ = interp2app(W_XRange.descr_repr),
- __getitem__ = interp2app(W_XRange.descr_getitem),
- __iter__ = interp2app(W_XRange.descr_iter),
- __len__ = interp2app(W_XRange.descr_len),
- __reversed__ = interp2app(W_XRange.descr_reversed),
- __reduce__ = interp2app(W_XRange.descr_reduce),
+W_Range.typedef = TypeDef("range",
+ __new__ = interp2app(W_Range.descr_new.im_func),
+ __repr__ = interp2app(W_Range.descr_repr),
+ __getitem__ = interp2app(W_Range.descr_getitem),
+ __iter__ = interp2app(W_Range.descr_iter),
+ __len__ = interp2app(W_Range.descr_len),
+ __reversed__ = interp2app(W_Range.descr_reversed),
+ __reduce__ = interp2app(W_Range.descr_reduce),
)
-class W_XRangeIterator(Wrappable):
+class W_RangeIterator(Wrappable):
def __init__(self, space, current, remaining, step):
self.space = space
self.current = current
@@ -631,17 +544,17 @@
space = self.space
w_mod = space.getbuiltinmodule('_pickle_support')
mod = space.interp_w(MixedModule, w_mod)
- new_inst = mod.get('xrangeiter_new')
+ new_inst = mod.get('rangeiter_new')
w = space.wrap
nt = space.newtuple
tup = [w(self.current), w(self.remaining), w(self.step)]
return nt([new_inst, nt(tup)])
-W_XRangeIterator.typedef = TypeDef("rangeiterator",
- __iter__ = interp2app(W_XRangeIterator.descr_iter),
+W_RangeIterator.typedef = TypeDef("rangeiterator",
+ __iter__ = interp2app(W_RangeIterator.descr_iter),
# XXX __length_hint__()
-## __len__ = interp2app(W_XRangeIterator.descr_len),
- next = interp2app(W_XRangeIterator.descr_next),
- __reduce__ = interp2app(W_XRangeIterator.descr_reduce),
+## __len__ = interp2app(W_RangeIterator.descr_len),
+ next = interp2app(W_RangeIterator.descr_next),
+ __reduce__ = interp2app(W_RangeIterator.descr_reduce),
)
diff --git a/pypy/module/__builtin__/test/test_builtin.py b/pypy/module/__builtin__/test/test_builtin.py
--- a/pypy/module/__builtin__/test/test_builtin.py
+++ b/pypy/module/__builtin__/test/test_builtin.py
@@ -275,84 +275,84 @@
assert next(x) == 2
assert next(x) == 3
- def test_xrange_args(self):
-## # xrange() attributes are deprecated and were removed in Python 2.3.
-## x = xrange(2)
+ def test_range_args(self):
+## # range() attributes are deprecated and were removed in Python 2.3.
+## x = range(2)
## assert x.start == 0
## assert x.stop == 2
## assert x.step == 1
-## x = xrange(2,10,2)
+## x = range(2,10,2)
## assert x.start == 2
## assert x.stop == 10
## assert x.step == 2
-## x = xrange(2.3, 10.5, 2.4)
+## x = range(2.3, 10.5, 2.4)
## assert x.start == 2
## assert x.stop == 10
## assert x.step == 2
- raises(ValueError, xrange, 0, 1, 0)
+ raises(ValueError, range, 0, 1, 0)
- def test_xrange_repr(self):
- assert repr(xrange(1)) == 'xrange(1)'
- assert repr(xrange(1,2)) == 'xrange(1, 2)'
- assert repr(xrange(1,2,3)) == 'xrange(1, 4, 3)'
+ def test_range_repr(self):
+ assert repr(range(1)) == 'range(1)'
+ assert repr(range(1,2)) == 'range(1, 2)'
+ assert repr(range(1,2,3)) == 'range(1, 4, 3)'
- def test_xrange_up(self):
- x = xrange(2)
+ def test_range_up(self):
+ x = range(2)
iter_x = iter(x)
assert iter_x.next() == 0
assert iter_x.next() == 1
raises(StopIteration, iter_x.next)
- def test_xrange_down(self):
- x = xrange(4,2,-1)
+ def test_range_down(self):
+ x = range(4,2,-1)
iter_x = iter(x)
assert iter_x.next() == 4
assert iter_x.next() == 3
raises(StopIteration, iter_x.next)
- def test_xrange_has_type_identity(self):
- assert type(xrange(1)) == type(xrange(1))
+ def test_range_has_type_identity(self):
+ assert type(range(1)) == type(range(1))
- def test_xrange_len(self):
- x = xrange(33)
+ def test_range_len(self):
+ x = range(33)
assert len(x) == 33
- x = xrange(33.2)
+ x = range(33.2)
assert len(x) == 33
- x = xrange(33,0,-1)
+ x = range(33,0,-1)
assert len(x) == 33
- x = xrange(33,0)
+ x = range(33,0)
assert len(x) == 0
- x = xrange(33,0.2)
+ x = range(33,0.2)
assert len(x) == 0
- x = xrange(0,33)
+ x = range(0,33)
assert len(x) == 33
- x = xrange(0,33,-1)
+ x = range(0,33,-1)
assert len(x) == 0
- x = xrange(0,33,2)
+ x = range(0,33,2)
assert len(x) == 17
- x = xrange(0,32,2)
+ x = range(0,32,2)
assert len(x) == 16
- def test_xrange_indexing(self):
- x = xrange(0,33,2)
+ def test_range_indexing(self):
+ x = range(0,33,2)
assert x[7] == 14
assert x[-7] == 20
raises(IndexError, x.__getitem__, 17)
raises(IndexError, x.__getitem__, -18)
raises(TypeError, x.__getitem__, slice(0,3,1))
- def test_xrange_bad_args(self):
- raises(TypeError, xrange, '1')
- raises(TypeError, xrange, None)
- raises(TypeError, xrange, 3+2j)
- raises(TypeError, xrange, 1, '1')
- raises(TypeError, xrange, 1, 3+2j)
- raises(TypeError, xrange, 1, 2, '1')
- raises(TypeError, xrange, 1, 2, 3+2j)
+ def test_range_bad_args(self):
+ raises(TypeError, range, '1')
+ raises(TypeError, range, None)
+ raises(TypeError, range, 3+2j)
+ raises(TypeError, range, 1, '1')
+ raises(TypeError, range, 1, 3+2j)
+ raises(TypeError, range, 1, 2, '1')
+ raises(TypeError, range, 1, 2, 3+2j)
def test_sorted(self):
l = []
diff --git a/pypy/objspace/std/model.py b/pypy/objspace/std/model.py
--- a/pypy/objspace/std/model.py
+++ b/pypy/objspace/std/model.py
@@ -25,8 +25,6 @@
"ropeobject.W_RopeIterObject"],
"withropeunicode": ["ropeunicodeobject.W_RopeUnicodeObject",
"ropeunicodeobject.W_RopeUnicodeIterObject"],
- "withrangelist" : ["rangeobject.W_RangeListObject",
- "rangeobject.W_RangeIterObject"],
"withtproxy" : ["proxyobject.W_TransparentList",
"proxyobject.W_TransparentDict"],
}
@@ -89,7 +87,6 @@
from pypy.objspace.std import iterobject
from pypy.objspace.std import unicodeobject
from pypy.objspace.std import dictproxyobject
- from pypy.objspace.std import rangeobject
from pypy.objspace.std import proxyobject
from pypy.objspace.std import fake
import pypy.objspace.std.default # register a few catch-all multimethods
@@ -250,11 +247,6 @@
(unicodeobject.W_UnicodeObject,
strbufobject.delegate_buf2unicode)
]
- if config.objspace.std.withrangelist:
- self.typeorder[rangeobject.W_RangeListObject] += [
- (listobject.W_ListObject,
- rangeobject.delegate_range2list),
- ]
if config.objspace.std.withsmalltuple:
self.typeorder[smalltupleobject.W_SmallTupleObject] += [
(tupleobject.W_TupleObject, smalltupleobject.delegate_SmallTuple2Tuple)]
diff --git a/pypy/objspace/std/rangeobject.py b/pypy/objspace/std/rangeobject.py
deleted file mode 100644
--- a/pypy/objspace/std/rangeobject.py
+++ /dev/null
@@ -1,226 +0,0 @@
-from pypy.interpreter.error import OperationError
-from pypy.objspace.std.model import registerimplementation, W_Object
-from pypy.objspace.std.register_all import register_all
-from pypy.objspace.std.multimethod import FailedToImplement
-from pypy.objspace.std.noneobject import W_NoneObject
-from pypy.objspace.std.inttype import wrapint
-from pypy.objspace.std.sliceobject import W_SliceObject, normalize_simple_slice
-from pypy.objspace.std.listobject import W_ListObject
-from pypy.objspace.std import listtype, iterobject, slicetype
-from pypy.interpreter import gateway, baseobjspace
-
-def length(start, stop, step):
- if step > 0:
- if stop <= start:
- return 0
- return (stop - start + step - 1)/step
-
- else: # step must be < 0
- if stop >= start:
- return 0
- return (start - stop - step - 1)/-step
-
-
-class W_RangeListObject(W_Object):
- typedef = listtype.list_typedef
-
- def __init__(w_self, start, step, length):
- assert step != 0
- w_self.start = start
- w_self.step = step
- w_self.length = length
- w_self.w_list = None
-
- def force(w_self, space):
- if w_self.w_list is not None:
- return w_self.w_list
- start = w_self.start
- step = w_self.step
- length = w_self.length
- if not length:
- w_self.w_list = space.newlist([])
- return w_self.w_list
-
- arr = [None] * length # this is to avoid using append.
-
- i = start
- n = 0
- while n < length:
- arr[n] = wrapint(space, i)
- i += step
- n += 1
-
- w_self.w_list = space.newlist(arr)
- return w_self.w_list
-
- def getitem(w_self, i):
- if i < 0:
- i += w_self.length
- if i < 0:
- raise IndexError
- elif i >= w_self.length:
- raise IndexError
- return w_self.start + i * w_self.step
-
- def getitem_unchecked(w_self, i):
- # bounds not checked, on purpose
- return w_self.start + i * w_self.step
-
- def __repr__(w_self):
- if w_self.w_list is None:
- return "W_RangeListObject(%s, %s, %s)" % (
- w_self.start, w_self.step, w_self.length)
- else:
- return "W_RangeListObject(%r)" % (w_self.w_list, )
-
-def delegate_range2list(space, w_rangelist):
- return w_rangelist.force(space)
-
-def len__RangeList(space, w_rangelist):
- if w_rangelist.w_list is not None:
- return space.len(w_rangelist.w_list)
- return wrapint(space, w_rangelist.length)
-
-
-def getitem__RangeList_ANY(space, w_rangelist, w_index):
- if w_rangelist.w_list is not None:
- return space.getitem(w_rangelist.w_list, w_index)
- idx = space.getindex_w(w_index, space.w_IndexError, "list index")
- try:
- return wrapint(space, w_rangelist.getitem(idx))
- except IndexError:
- raise OperationError(space.w_IndexError,
- space.wrap("list index out of range"))
-
-def getitem__RangeList_Slice(space, w_rangelist, w_slice):
- if w_rangelist.w_list is not None:
- return space.getitem(w_rangelist.w_list, w_slice)
- length = w_rangelist.length
- start, stop, step, slicelength = w_slice.indices4(space, length)
- assert slicelength >= 0
- rangestart = w_rangelist.getitem_unchecked(start)
- rangestep = w_rangelist.step * step
- return W_RangeListObject(rangestart, rangestep, slicelength)
-
-def iter__RangeList(space, w_rangelist):
- return W_RangeIterObject(w_rangelist)
-
-def repr__RangeList(space, w_rangelist):
- if w_rangelist.w_list is not None:
- return space.repr(w_rangelist.w_list)
- if w_rangelist.length == 0:
- return space.wrap('[]')
- result = [''] * w_rangelist.length
- i = w_rangelist.start
- n = 0
- while n < w_rangelist.length:
- result[n] = str(i)
- i += w_rangelist.step
- n += 1
- return space.wrap("[" + ", ".join(result) + "]")
-
-def inplace_add__RangeList_ANY(space, w_rangelist, w_iterable2):
- space.inplace_add(w_rangelist.force(space), w_iterable2)
- return w_rangelist
-
-def inplace_mul__RangeList_ANY(space, w_rangelist, w_number):
- space.inplace_mul(w_rangelist.force(space), w_number)
- return w_rangelist
-
-
-def list_pop__RangeList_ANY(space, w_rangelist, w_idx=-1):
- if w_rangelist.w_list is not None:
- raise FailedToImplement
- length = w_rangelist.length
- if length == 0:
- raise OperationError(space.w_IndexError,
- space.wrap("pop from empty list"))
- if space.isinstance_w(w_idx, space.w_float):
- raise OperationError(space.w_TypeError,
- space.wrap("integer argument expected, got float")
- )
- idx = space.int_w(space.int(w_idx))
- if idx == 0:
- result = w_rangelist.start
- w_rangelist.start += w_rangelist.step
- w_rangelist.length -= 1
- return wrapint(space, result)
- if idx == -1 or idx == length - 1:
- w_rangelist.length -= 1
- return wrapint(
- space, w_rangelist.start + (length - 1) * w_rangelist.step)
- if idx >= w_rangelist.length:
- raise OperationError(space.w_IndexError,
- space.wrap("pop index out of range"))
- raise FailedToImplement
-
-def list_reverse__RangeList(space, w_rangelist):
- # probably somewhat useless, but well...
- if w_rangelist.w_list is not None:
- raise FailedToImplement
- w_rangelist.start = w_rangelist.getitem_unchecked(w_rangelist.length-1)
- w_rangelist.step = -w_rangelist.step
-
-def list_sort__RangeList_None_None_ANY(space, w_rangelist, w_cmp,
- w_keyfunc, w_reverse):
- # even more useless but fun
- has_reverse = space.is_true(w_reverse)
- if w_rangelist.w_list is not None:
- raise FailedToImplement
- if has_reverse:
- factor = -1
- else:
- factor = 1
- reverse = w_rangelist.step * factor < 0
- if reverse:
- w_rangelist.start = w_rangelist.getitem_unchecked(w_rangelist.length-1)
- w_rangelist.step = -w_rangelist.step
- return space.w_None
-
-
-class W_RangeIterObject(iterobject.W_AbstractSeqIterObject):
- pass
-
-def iter__RangeIter(space, w_rangeiter):
- return w_rangeiter
-
-def next__RangeIter(space, w_rangeiter):
- w_rangelist = w_rangeiter.w_seq
- if w_rangelist is None:
- raise OperationError(space.w_StopIteration, space.w_None)
- assert isinstance(w_rangelist, W_RangeListObject)
- index = w_rangeiter.index
- if w_rangelist.w_list is not None:
- try:
- w_item = space.getitem(w_rangelist.w_list,
- wrapint(space, index))
- except OperationError, e:
- w_rangeiter.w_seq = None
- if not e.match(space, space.w_IndexError):
- raise
- raise OperationError(space.w_StopIteration, space.w_None)
- else:
- if index >= w_rangelist.length:
- w_rangeiter.w_seq = None
- raise OperationError(space.w_StopIteration, space.w_None)
- w_item = wrapint(
- space,
- w_rangelist.getitem_unchecked(index))
- w_rangeiter.index = index + 1
- return w_item
-
-# XXX __length_hint__()
-##def len__RangeIter(space, w_rangeiter):
-## if w_rangeiter.w_seq is None:
-## return wrapint(space, 0)
-## index = w_rangeiter.index
-## w_length = space.len(w_rangeiter.w_seq)
-## w_len = space.sub(w_length, wrapint(space, index))
-## if space.is_true(space.lt(w_len, wrapint(space, 0))):
-## w_len = wrapint(space, 0)
-## return w_len
-
-registerimplementation(W_RangeListObject)
-registerimplementation(W_RangeIterObject)
-
-register_all(vars(), listtype)
diff --git a/pypy/objspace/std/test/test_rangeobject.py b/pypy/objspace/std/test/test_rangeobject.py
deleted file mode 100644
--- a/pypy/objspace/std/test/test_rangeobject.py
+++ /dev/null
@@ -1,153 +0,0 @@
-import py
-
-from pypy.conftest import gettestobjspace, option
-
-class AppTestRangeListObject(object):
-
- def setup_class(cls):
- if option.runappdirect:
- py.test.skip("__pypy__.internal_repr() cannot be used to see "
- "if a range list was forced on top of pypy-c")
- cls.space = gettestobjspace(**{"objspace.std.withrangelist": True})
- cls.w_not_forced = cls.space.appexec([], """():
- import __pypy__
- def f(r):
- return (isinstance(r, list) and
- "W_ListObject" not in __pypy__.internal_repr(r))
- return f
- """)
- cls.w_SORT_FORCES_LISTS = cls.space.wrap(False)
-
- def test_simple(self):
- result = []
- r = range(1, 8, 2)
- for i in r:
- result.append(i)
- assert result == [1, 3, 5, 7]
- assert self.not_forced(r)
-
- def test_getitem_slice(self):
- result = []
- r = range(1, 100, 2)
- for i in r[10:15]:
- result.append(i)
- assert result == [21, 23, 25, 27, 29]
- assert self.not_forced(r)
-
- def test_getitem_extended_slice(self):
- result = []
- r = range(1, 100, 2)
- for i in r[40:30:-2]:
- result.append(i)
- assert result == [81, 77, 73, 69, 65]
- assert self.not_forced(r)
-
- def test_empty_range(self):
- r = range(10, 10)
- if not self.SORT_FORCES_LISTS:
- r.sort(reverse=True)
- assert len(r) == 0
- assert list(reversed(r)) == []
- assert r[:] == []
- assert self.not_forced(r)
-
- def test_repr(self):
- r = range(5)
- assert repr(r) == "[0, 1, 2, 3, 4]"
- assert self.not_forced(r)
-
- def test_force(self):
- r = range(10)
- r[0] = 42
- assert not self.not_forced(r)
- assert r == [42, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
- def test_reverse(self):
- r = range(10)
- r.reverse()
- assert self.not_forced(r)
- assert r == range(9, -1, -1)
- r = range(3)
- r[0] = 1
- assert r == [1, 1, 2]
- r.reverse()
- assert r == [2, 1, 1]
-
- def test_sort(self):
- if self.SORT_FORCES_LISTS:
- skip("sort() forces these lists")
- r = range(10, -1, -1)
- r.sort()
- assert self.not_forced(r)
- assert r == range(11)
- r = range(11)
- r.sort(reverse=True)
- assert self.not_forced(r)
- assert r == range(10, -1, -1)
- r = range(100)
- r[0] = 999
- assert not self.not_forced(r)
- r.sort()
- assert r == range(1, 100) + [999]
- r = range(10)
- r.sort(key=lambda x: -x)
- assert r == range(9, -1, -1)
-
- def test_pop(self):
- r = range(10)
- res = r.pop()
- assert res == 9
- assert self.not_forced(r)
- assert repr(r) == repr(range(9))
- res = r.pop(0)
- assert res == 0
- assert self.not_forced(r)
- assert repr(r) == repr(range(1, 9))
- res = r.pop(len(r) - 1)
- assert res == 8
- assert self.not_forced(r)
- assert repr(r) == repr(range(1, 8))
- res = r.pop(2)
- assert res == 3
- assert not self.not_forced(r)
- assert r == [1, 2, 4, 5, 6, 7]
- res = r.pop(2)
- assert res == 4
- assert not self.not_forced(r)
- assert r == [1, 2, 5, 6, 7]
-
- def test_reduce(self):
- it = iter(range(10))
- assert it.next() == 0
- assert it.next() == 1
- assert it.next() == 2
- assert it.next() == 3
- seqiter_new, args = it.__reduce__()
- assert it.next() == 4
- assert it.next() == 5
- it2 = seqiter_new(*args)
- assert it2.next() == 4
- assert it2.next() == 5
- it3 = seqiter_new(*args)
- assert it3.next() == 4
- assert it3.next() == 5
-
- def test_no_len_on_range_iter(self):
- iterable = range(10)
- raises(TypeError, len, iter(iterable))
-
- def test_inplace_add(self):
- r1 = r2 = range(5)
- assert r1 is r2
- r1 += [15]
- assert r1 is r2
- assert r1 == [0, 1, 2, 3, 4, 15]
- assert r2 == [0, 1, 2, 3, 4, 15]
-
- def test_inplace_mul(self):
- r1 = r2 = range(3)
- assert r1 is r2
- r1 *= 2
- assert r1 is r2
- assert r1 == [0, 1, 2, 0, 1, 2]
- assert r2 == [0, 1, 2, 0, 1, 2]
More information about the pypy-commit
mailing list