Remove the simple slicing API. All slicing is now done with slice objects.
diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py
index a8a7e76..9d53077 100644
--- a/Lib/test/list_tests.py
+++ b/Lib/test/list_tests.py
@@ -178,10 +178,8 @@
a[:] = tuple(range(10))
self.assertEqual(a, self.type2test(range(10)))
- self.assertRaises(TypeError, a.__setslice__, 0, 1, 5)
self.assertRaises(TypeError, a.__setitem__, slice(0, 1, 5))
- self.assertRaises(TypeError, a.__setslice__)
self.assertRaises(TypeError, a.__setitem__)
def test_delslice(self):
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index 6ec03e8..eb6d141 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -196,8 +196,6 @@
self.assertEqual(a[ -pow(2,128): 3 ], self.type2test([0,1,2]))
self.assertEqual(a[ 3: pow(2,145) ], self.type2test([3,4]))
- self.assertRaises(TypeError, u.__getslice__)
-
def test_contains(self):
u = self.type2test([0, 1, 2])
for i in u:
diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
index 916a98f..9e178ca 100644
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -939,17 +939,17 @@
self.checkraises(TypeError, 'abc', '__getitem__', 'def')
def test_slice(self):
- self.checkequal('abc', 'abc', '__getslice__', 0, 1000)
- self.checkequal('abc', 'abc', '__getslice__', 0, 3)
- self.checkequal('ab', 'abc', '__getslice__', 0, 2)
- self.checkequal('bc', 'abc', '__getslice__', 1, 3)
- self.checkequal('b', 'abc', '__getslice__', 1, 2)
- self.checkequal('', 'abc', '__getslice__', 2, 2)
- self.checkequal('', 'abc', '__getslice__', 1000, 1000)
- self.checkequal('', 'abc', '__getslice__', 2000, 1000)
- self.checkequal('', 'abc', '__getslice__', 2, 1)
+ self.checkequal('abc', 'abc', '__getitem__', slice(0, 1000))
+ self.checkequal('abc', 'abc', '__getitem__', slice(0, 3))
+ self.checkequal('ab', 'abc', '__getitem__', slice(0, 2))
+ self.checkequal('bc', 'abc', '__getitem__', slice(1, 3))
+ self.checkequal('b', 'abc', '__getitem__', slice(1, 2))
+ self.checkequal('', 'abc', '__getitem__', slice(2, 2))
+ self.checkequal('', 'abc', '__getitem__', slice(1000, 1000))
+ self.checkequal('', 'abc', '__getitem__', slice(2000, 1000))
+ self.checkequal('', 'abc', '__getitem__', slice(2, 1))
- self.checkraises(TypeError, 'abc', '__getslice__', 'def')
+ self.checkraises(TypeError, 'abc', '__getitem__', 'def')
def test_extended_getslice(self):
# Test extended slicing by comparing with list slicing.
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index bae496e..db029f3 100755
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -562,12 +562,10 @@
)
a = array.array(self.typecode, self.example)
- self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
self.assertRaises(TypeError, a.__setitem__, slice(0, 0), None)
self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
b = array.array(self.badtypecode())
- self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
self.assertRaises(TypeError, a.__setitem__, slice(0, 0), b)
self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index bde63a8..76b30a3 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -36,11 +36,8 @@
# List/dict operations
"contains",
"getitem",
- "getslice",
"setitem",
- "setslice",
"delitem",
- "delslice",
# Unary operations
"neg",
@@ -288,15 +285,16 @@
callLst[:] = []
testme[:42]
- self.assertCallStack([('__getslice__', (testme, 0, 42))])
+ self.assertCallStack([('__getitem__', (testme, slice(None, 42)))])
callLst[:] = []
testme[:42] = "The Answer"
- self.assertCallStack([('__setslice__', (testme, 0, 42, "The Answer"))])
+ self.assertCallStack([('__setitem__', (testme, slice(None, 42),
+ "The Answer"))])
callLst[:] = []
del testme[:42]
- self.assertCallStack([('__delslice__', (testme, 0, 42))])
+ self.assertCallStack([('__delitem__', (testme, slice(None, 42)))])
callLst[:] = []
testme[2:1024:10]
@@ -329,37 +327,6 @@
slice(None, 24, None),
24, 100)))])
- # Now remove the slice hooks to see if converting normal slices to
- # slice object works.
-
- getslice = AllTests.__getslice__
- del AllTests.__getslice__
- setslice = AllTests.__setslice__
- del AllTests.__setslice__
- delslice = AllTests.__delslice__
- del AllTests.__delslice__
-
- # XXX when using new-style classes the slice testme[:42] produces
- # slice(None, 42, None) instead of slice(0, 42, None). py3k will have
- # to change this test.
- callLst[:] = []
- testme[0:42]
- self.assertCallStack([('__getitem__', (testme, slice(0, 42, None)))])
-
- callLst[:] = []
- testme[:42] = "The Answer"
- self.assertCallStack([('__setitem__', (testme, slice(None, 42, None),
- "The Answer"))])
- callLst[:] = []
- del testme[0:42]
- self.assertCallStack([('__delitem__', (testme, slice(0, 42, None)))])
-
- # Restore the slice methods, or the tests will fail with regrtest -R.
- AllTests.__getslice__ = getslice
- AllTests.__setslice__ = setslice
- AllTests.__delslice__ = delslice
-
-
def testUnaryOps(self):
testme = AllTests()
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 69400ee..47b647c 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -41,7 +41,7 @@
bm = getattr(a, meth)
vereq(bm(b), res)
-def testternop(a, b, c, res, expr="a[b:c]", meth="__getslice__"):
+def testsliceop(a, b, c, res, expr="a[b:c]", meth="__getitem__"):
if verbose: print("checking", expr)
dict = {'a': a, 'b': b, 'c': c}
vereq(eval(expr, dict), res)
@@ -50,9 +50,9 @@
while meth not in t.__dict__:
t = t.__bases__[0]
vereq(m, t.__dict__[meth])
- vereq(m(a, b, c), res)
+ vereq(m(a, slice(b, c)), res)
bm = getattr(a, meth)
- vereq(bm(b, c), res)
+ vereq(bm(slice(b, c)), res)
def testsetop(a, b, res, stmt="a+=b", meth="__iadd__"):
if verbose: print("checking", stmt)
@@ -90,7 +90,7 @@
bm(b, c)
vereq(dict['a'], res)
-def testset3op(a, b, c, d, res, stmt="a[b:c]=d", meth="__setslice__"):
+def testsetsliceop(a, b, c, d, res, stmt="a[b:c]=d", meth="__setitem__"):
if verbose: print("checking", stmt)
dict = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d}
exec(stmt, dict)
@@ -101,11 +101,11 @@
m = getattr(t, meth)
vereq(m, t.__dict__[meth])
dict['a'] = deepcopy(a)
- m(dict['a'], b, c, d)
+ m(dict['a'], slice(b, c), d)
vereq(dict['a'], res)
dict['a'] = deepcopy(a)
bm = getattr(dict['a'], meth)
- bm(b, c, d)
+ bm(slice(b, c), d)
vereq(dict['a'], res)
def class_docstrings():
@@ -142,14 +142,15 @@
testbinop([1,2,3], 2, 1, "b in a", "__contains__")
testbinop([1,2,3], 4, 0, "b in a", "__contains__")
testbinop([1,2,3], 1, 2, "a[b]", "__getitem__")
- testternop([1,2,3], 0, 2, [1,2], "a[b:c]", "__getslice__")
+ testsliceop([1,2,3], 0, 2, [1,2], "a[b:c]", "__getitem__")
testsetop([1], [2], [1,2], "a+=b", "__iadd__")
testsetop([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__")
testunop([1,2,3], 3, "len(a)", "__len__")
testbinop([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__")
testbinop([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__")
testset2op([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__")
- testset3op([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", "__setslice__")
+ testsetsliceop([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d",
+ "__setitem__")
def dicts():
if verbose: print("Testing dict operations...")
@@ -485,8 +486,8 @@
testbinop(spamlist([1,2,3]), 2, 1, "b in a", "__contains__")
testbinop(spamlist([1,2,3]), 4, 0, "b in a", "__contains__")
testbinop(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__")
- testternop(spamlist([1,2,3]), 0, 2, spamlist([1,2]),
- "a[b:c]", "__getslice__")
+ testsliceop(spamlist([1,2,3]), 0, 2, spamlist([1,2]),
+ "a[b:c]", "__getitem__")
testsetop(spamlist([1]), spamlist([2]), spamlist([1,2]),
"a+=b", "__iadd__")
testsetop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b", "__imul__")
@@ -494,8 +495,8 @@
testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b", "__mul__")
testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a", "__rmul__")
testset2op(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c", "__setitem__")
- testset3op(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),
- spamlist([1,5,6,4]), "a[b:c]=d", "__setslice__")
+ testsetsliceop(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),
+ spamlist([1,5,6,4]), "a[b:c]=d", "__setitem__")
# Test subclassing
class C(spam.spamlist):
def foo(self): return 1
@@ -609,9 +610,9 @@
if verbose: print("Testing Python subclass of list...")
class C(list):
def __getitem__(self, i):
+ if isinstance(i, slice):
+ return (i.start, i.stop)
return list.__getitem__(self, i) + 100
- def __getslice__(self, i, j):
- return (i, j)
a = C()
a.extend([0,1,2])
vereq(a[0], 100)
@@ -1651,13 +1652,6 @@
def __delitem__(self, key):
self.delitem = key
- def __getslice__(self, i, j):
- return ("getslice", i, j)
- def __setslice__(self, i, j, value):
- self.setslice = (i, j, value)
- def __delslice__(self, i, j):
- self.delslice = (i, j)
-
a = C()
vereq(a.foo, ("getattr", "foo"))
a.foo = 12
@@ -1671,11 +1665,11 @@
del a[12]
vereq(a.delitem, 12)
- vereq(a[0:10], ("getslice", 0, 10))
+ vereq(a[0:10], ("getitem", slice(0, 10)))
a[0:10] = "foo"
- vereq(a.setslice, (0, 10, "foo"))
+ vereq(a.setitem, (slice(0, 10), "foo"))
del a[0:10]
- vereq(a.delslice, (0, 10))
+ vereq(a.delitem, slice(0, 10))
def methods():
if verbose: print("Testing methods...")
@@ -4116,7 +4110,7 @@
# tp->tp_as_sequence->sq_ass_slice
class C(object):
- def __setslice__(self, start, stop, value):
+ def __setitem__(self, idx, value):
self.value = value
c = C()
diff --git a/Lib/test/test_descrtut.py b/Lib/test/test_descrtut.py
index 8080e41..ea75366 100644
--- a/Lib/test/test_descrtut.py
+++ b/Lib/test/test_descrtut.py
@@ -170,14 +170,12 @@
'__contains__',
'__delattr__',
'__delitem__',
- '__delslice__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
- '__getslice__',
'__gt__',
'__hash__',
'__iadd__',
@@ -197,7 +195,6 @@
'__rmul__',
'__setattr__',
'__setitem__',
- '__setslice__',
'__str__',
'append',
'count',
diff --git a/Lib/test/test_index.py b/Lib/test/test_index.py
index 653665e..6275e12 100644
--- a/Lib/test/test_index.py
+++ b/Lib/test/test_index.py
@@ -177,26 +177,17 @@
self.assertEqual(self.pos.__index__(), self.pos)
self.assertEqual(self.neg.__index__(), self.neg)
- def _getitem_helper(self, base):
- class GetItem(base):
+ def test_getitem(self):
+ class GetItem(object):
def __len__(self):
return maxint #cannot return long here
def __getitem__(self, key):
return key
- def __getslice__(self, i, j):
- return i, j
x = GetItem()
self.assertEqual(x[self.pos], self.pos)
self.assertEqual(x[self.neg], self.neg)
- self.assertEqual(x[self.neg:self.pos], (maxint+minsize, maxsize))
- self.assertEqual(x[self.neg:self.pos:1].indices(maxsize), (0, maxsize, 1))
-
- def test_getitem(self):
- self._getitem_helper(object)
-
- def test_getitem_classic(self):
- class Empty: pass
- self._getitem_helper(Empty)
+ self.assertEqual(x[self.neg:self.pos].indices(maxsize),
+ (0, maxsize, 1))
def test_sequence_repeat(self):
self.failUnlessRaises(OverflowError, lambda: "a" * self.pos)
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index 4ba825a..bdda5d8 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -283,17 +283,6 @@
self.assert_(type(y) is int,
"overflowing int conversion must return long not long subtype")
- # long -> Py_ssize_t conversion
- class X(object):
- def __getslice__(self, i, j):
- return i, j
-
- self.assertEqual(X()[-5:7], (-5, 7))
- # use the clamping effect to test the smallest and largest longs
- # that fit a Py_ssize_t
- slicemin, slicemax = X()[-2**100:2**100]
- self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax))
-
# ----------------------------------- tests of auto int->long conversion
def test_auto_overflow(self):
diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py
index 97b3084..cb9d8b2 100644
--- a/Lib/test/test_slice.py
+++ b/Lib/test/test_slice.py
@@ -99,12 +99,12 @@
def test_setslice_without_getslice(self):
tmp = []
class X(object):
- def __setslice__(self, i, j, k):
- tmp.append((i, j, k))
+ def __setitem__(self, i, k):
+ tmp.append((i, k))
x = X()
x[1:2] = 42
- self.assertEquals(tmp, [(1, 2, 42)])
+ self.assertEquals(tmp, [(slice(1, 2), 42)])
def test_pickle(self):
s = slice(10, 20, 3)
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index 637043d..5b2176e 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -423,11 +423,7 @@
_1G = 1024 * _1M
_2G = 2 * _1G
-# Hack to get at the maximum value an internal index can take.
-class _Dummy:
- def __getslice__(self, i, j):
- return j
-MAX_Py_ssize_t = _Dummy()[:]
+MAX_Py_ssize_t = sys.maxsize
def set_memlimit(limit):
import re