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
123
124
125
126
127
128
129
130
131
132
|
import sys
from pypy.objspace.std.sliceobject import normalize_simple_slice
class TestW_SliceObject:
def test_unpack(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.unpack(space) == (0, sys.maxint, 1)
w_slice = space.newslice(w(0), w(6), w(1))
assert w_slice.unpack(space) == (0, 6, 1)
w_slice = space.newslice(w_None, w_None, w(-1))
assert w_slice.unpack(space) == (sys.maxint, -sys.maxint-1, -1)
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
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)")
|
