1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
import sys
from pypy.objspace.std.sliceobject import normalize_simple_slice
class TestW_SliceObject:
def test_indices(self):
space = self.space
w = space.wrap
w_None = space.w_None
w_slice = space.newslice(w_None, w_None, w_None)
assert w_slice.indices3(space, 6) == (0, 6, 1)
w_slice = space.newslice(w(0), w(6), w(1))
assert w_slice.indices3(space, 6) == (0, 6, 1)
w_slice = space.newslice(w_None, w_None, w(-1))
assert w_slice.indices3(space, 6) == (5, -1, -1)
def test_indices_fail(self):
space = self.space
w = space.wrap
w_None = space.w_None
w_slice = space.newslice(w_None, w_None, w(0))
self.space.raises_w(space.w_ValueError, w_slice.indices3, space, 10)
def test_normalize_simple_slice(self):
space = self.space
w = space.wrap
def getslice(length, start, stop):
# returns range(length)[start:stop] but without special
# support for negative start or stop
return [i for i in range(length) if start <= i < stop]
assert getslice(10, 2, 5) == [2, 3, 4]
for length in range(5):
for start in range(-2*length-2, 2*length+3):
for stop in range(-2*length-2, 2*length+3):
mystart, mystop = normalize_simple_slice(space, length,
w(start), w(stop))
assert 0 <= mystart <= mystop <= length
assert (getslice(length, start, stop) ==
getslice(length, mystart, mystop))
def test_indexes4(self):
space = self.space
w = space.wrap
def getslice(length, start, stop, step):
return [i for i in range(0, length, step) if start <= i < stop]
for step in [-5, -4, -3, -2, -1, 1, 2, 3, 4, 5, None]:
for length in range(5):
for start in range(-2*length-2, 2*length+3) + [None]:
for stop in range(-2*length-2, 2*length+3) + [None]:
sl = space.newslice(w(start), w(stop), w(step))
mystart, mystop, mystep, slicelength = sl.indices4(space, length)
assert len(range(length)[start:stop:step]) == slicelength
if sys.version_info >= (2, 6): # doesn't work in 2.5
assert slice(start, stop, step).indices(length) == (
mystart, mystop, mystep)
class AppTest_SliceObject:
def test_new(self):
def cmp_slice(sl1, sl2):
for attr in "start", "stop", "step":
if getattr(sl1, attr) != getattr(sl2, attr):
return False
return True
raises(TypeError, slice)
raises(TypeError, slice, 1, 2, 3, 4)
assert cmp_slice(slice(23), slice(None, 23, None))
assert cmp_slice(slice(23, 45), slice(23, 45, None))
def test_indices(self):
assert slice(4,11,2).indices(28) == (4, 11, 2)
assert slice(4,11,2).indices(8) == (4, 8, 2)
assert slice(4,11,2).indices(2) == (2, 2, 2)
assert slice(11,4,-2).indices(28) == (11, 4, -2)
assert slice(11,4,-2).indices(8) == (7, 4, -2)
assert slice(11,4,-2).indices(2) == (1, 1, -2)
assert slice(None, -9).indices(10) == (0, 1, 1)
assert slice(None, -10, -1).indices(10) == (9, 0, -1)
assert slice(None, 10, -1).indices(10) == (9, 9, -1)
def test_repr(self):
assert repr(slice(1, 2, 3)) == 'slice(1, 2, 3)'
assert repr(slice(1, 2)) == 'slice(1, 2, None)'
assert repr(slice('a', 'b')) == "slice('a', 'b', None)"
def test_eq(self):
slice1 = slice(1, 2, 3)
slice2 = slice(1, 2, 3)
assert slice1 == slice2
assert not slice1 != slice2
slice2 = slice(1, 2)
assert slice1 != slice2
def test_lt(self):
assert slice(0, 2, 3) < slice(1, 0, 0)
assert slice(0, 1, 3) < slice(0, 2, 0)
assert slice(0, 1, 2) < slice(0, 1, 3)
assert not (slice(1, 2, 3) < slice(0, 0, 0))
assert not (slice(1, 2, 3) < slice(1, 0, 0))
assert not (slice(1, 2, 3) < slice(1, 2, 0))
assert not (slice(1, 2, 3) < slice(1, 2, 3))
def test_long_indices(self):
assert slice(-2 ** 100, 10, 1).indices(1000) == (0, 10, 1)
assert slice(-2 ** 200, -2 ** 100, 1).indices(1000) == (0, 0, 1)
assert slice(2 ** 100, 0, -1).indices(1000) == (999, 0, -1)
assert slice(2 ** 100, -2 ** 100, -1).indices(1000) == (999, -1, -1)
assert slice(0, 1000, 2 ** 200).indices(1000) == (0, 1000, 2 ** 200)
assert slice(0, 1000, 1).indices(2 ** 100) == (0, 1000, 1)
def test_reduce(self):
assert slice(1, 2, 3).__reduce__() == (slice, (1, 2, 3))
def test_indices_negative_length(self):
raises(ValueError, "slice(0, 1000, 1).indices(-1)")
|
